../src/node_options-inl.h

Bug Summary

File:	out/../src/node_options-inl.h
Warning:	line 193, column 1 Potential leak of memory pointed to by field '_M_pi'

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name node_options.cc -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/home/maurizio/node-v18.6.0/out -resource-dir /usr/local/lib/clang/16.0.0 -D V8_DEPRECATION_WARNINGS -D V8_IMMINENT_DEPRECATION_WARNINGS -D _GLIBCXX_USE_CXX11_ABI=1 -D NODE_OPENSSL_CONF_NAME=nodejs_conf -D NODE_OPENSSL_HAS_QUIC -D __STDC_FORMAT_MACROS -D OPENSSL_NO_PINSHARED -D OPENSSL_THREADS -D NODE_ARCH="x64" -D NODE_PLATFORM="linux" -D NODE_WANT_INTERNALS=1 -D V8_DEPRECATION_WARNINGS=1 -D NODE_OPENSSL_SYSTEM_CERT_PATH="" -D NODE_USE_NODE_CODE_CACHE=1 -D HAVE_INSPECTOR=1 -D NODE_ENABLE_LARGE_CODE_PAGES=1 -D __POSIX__ -D NODE_USE_V8_PLATFORM=1 -D NODE_HAVE_I18N_SUPPORT=1 -D HAVE_OPENSSL=1 -D OPENSSL_API_COMPAT=0x10100000L -D UCONFIG_NO_SERVICE=1 -D U_ENABLE_DYLOAD=0 -D U_STATIC_IMPLEMENTATION=1 -D U_HAVE_STD_STRING=1 -D UCONFIG_NO_BREAK_ITERATION=0 -D _LARGEFILE_SOURCE -D _FILE_OFFSET_BITS=64 -D _POSIX_C_SOURCE=200112 -D NGHTTP2_STATICLIB -D NDEBUG -D OPENSSL_USE_NODELETE -D L_ENDIAN -D OPENSSL_BUILDING_OPENSSL -D AES_ASM -D BSAES_ASM -D CMLL_ASM -D ECP_NISTZ256_ASM -D GHASH_ASM -D KECCAK1600_ASM -D MD5_ASM -D OPENSSL_BN_ASM_GF2m -D OPENSSL_BN_ASM_MONT -D OPENSSL_BN_ASM_MONT5 -D OPENSSL_CPUID_OBJ -D OPENSSL_IA32_SSE2 -D PADLOCK_ASM -D POLY1305_ASM -D SHA1_ASM -D SHA256_ASM -D SHA512_ASM -D VPAES_ASM -D WHIRLPOOL_ASM -D X25519_ASM -D OPENSSL_PIC -D NGTCP2_STATICLIB -D NGHTTP3_STATICLIB -I ../src -I /home/maurizio/node-v18.6.0/out/Release/obj/gen -I /home/maurizio/node-v18.6.0/out/Release/obj/gen/include -I /home/maurizio/node-v18.6.0/out/Release/obj/gen/src -I ../deps/googletest/include -I ../deps/histogram/src -I ../deps/uvwasi/include -I ../deps/v8/include -I ../deps/icu-small/source/i18n -I ../deps/icu-small/source/common -I ../deps/zlib -I ../deps/llhttp/include -I ../deps/cares/include -I ../deps/uv/include -I ../deps/nghttp2/lib/includes -I ../deps/brotli/c/include -I ../deps/openssl/openssl/include -I ../deps/openssl/openssl/crypto/include -I ../deps/openssl/config/archs/linux-x86_64/asm/include -I ../deps/openssl/config/archs/linux-x86_64/asm -I ../deps/ngtcp2 -I ../deps/ngtcp2/ngtcp2/lib/includes -I ../deps/ngtcp2/ngtcp2/crypto/includes -I ../deps/ngtcp2/nghttp3/lib/includes -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/x86_64-redhat-linux -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/backward -internal-isystem /usr/local/lib/clang/16.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-unused-parameter -Wno-unused-parameter -std=gnu++17 -fdeprecated-macro -fdebug-compilation-dir=/home/maurizio/node-v18.6.0/out -ferror-limit 19 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-08-22-142216-507842-1 -x c++ ../src/node_options.cc

../src/node_options.cc

→

1#include "node_options.h"  // NOLINT(build/include_inline)
2#include "node_options-inl.h"

4#include "env-inl.h"
5#include "node_binding.h"
6#include "node_external_reference.h"
7#include "node_internals.h"
8#if HAVE_OPENSSL1
9#include "openssl/opensslv.h"
10#endif

12#include <errno(*__errno_location ()).h>
13#include <sstream>
14#include <limits>
15#include <algorithm>
16#include <cstdlib>  // strtoul, errno

18using v8::Boolean;
19using v8::Context;
20using v8::FunctionCallbackInfo;
21using v8::Integer;
22using v8::Isolate;
23using v8::Local;
24using v8::Map;
25using v8::Number;
26using v8::Object;
27using v8::Undefined;
28using v8::Value;

30namespace node {

32namespace per_process {
33Mutex cli_options_mutex;
34std::shared_ptr<PerProcessOptions> cli_options{new PerProcessOptions()};
35}  // namespace per_process

37void DebugOptions::CheckOptions(std::vector<std::string>* errors) {
38#if !NODE_USE_V8_PLATFORM1 && !HAVE_INSPECTOR1
if (inspector_enabled) {
  errors->push_back("Inspector is not available when Node is compiled "
                    "--without-v8-platform and --without-inspector.");
}
43#endif

if (deprecated_debug) {
  errors->push_back("[DEP0062]: `node --debug` and `node --debug-brk` "
                    "are invalid. Please use `node --inspect` and "
                    "`node --inspect-brk` instead.");
}

std::vector<std::string> destinations =
    SplitString(inspect_publish_uid_string, ',');
inspect_publish_uid.console = false;
inspect_publish_uid.http = false;
for (const std::string& destination : destinations) {
  if (destination == "stderr") {
    inspect_publish_uid.console = true;
  } else if (destination == "http") {
    inspect_publish_uid.http = true;
  } else {
    errors->push_back("--inspect-publish-uid destination can be "
                      "stderr or http");
  }
}
65}

67void PerProcessOptions::CheckOptions(std::vector<std::string>* errors) {
68#if HAVE_OPENSSL1
if (use_openssl_ca && use_bundled_ca) {
  errors->push_back("either --use-openssl-ca or --use-bundled-ca can be "
                    "used, not both");
}

// Any value less than 2 disables use of the secure heap.
if (secure_heap >= 2) {
  if ((secure_heap & (secure_heap - 1)) != 0)
    errors->push_back("--secure-heap must be a power of 2");
  secure_heap_min =
      std::min({
          secure_heap,
          secure_heap_min,
          static_cast<int64_t>(std::numeric_limits<int>::max())});
  secure_heap_min = std::max(static_cast<int64_t>(2), secure_heap_min);
  if ((secure_heap_min & (secure_heap_min - 1)) != 0)
    errors->push_back("--secure-heap-min must be a power of 2");
}
87#endif  // HAVE_OPENSSL

if (use_largepages != "off" &&
    use_largepages != "on" &&
    use_largepages != "silent") {
  errors->push_back("invalid value for --use-largepages");
}
per_isolate->CheckOptions(errors);
95}

97void PerIsolateOptions::CheckOptions(std::vector<std::string>* errors) {
per_env->CheckOptions(errors);
99}

101void EnvironmentOptions::CheckOptions(std::vector<std::string>* errors) {
if (has_policy_integrity_string && experimental_policy.empty()) {
  errors->push_back("--policy-integrity requires "
                    "--experimental-policy be enabled");
}
if (has_policy_integrity_string && experimental_policy_integrity.empty()) {
  errors->push_back("--policy-integrity cannot be empty");
}

if (!module_type.empty()) {
  if (module_type != "commonjs" && module_type != "module") {
    errors->push_back("--input-type must be \"module\" or \"commonjs\"");
  }
}

if (!experimental_specifier_resolution.empty()) {
  if (experimental_specifier_resolution != "node" &&
      experimental_specifier_resolution != "explicit") {
    errors->push_back(
      "invalid value for --experimental-specifier-resolution");
  }
}

if (syntax_check_only && has_eval_string) {
  errors->push_back("either --check or --eval can be used, not both");
}

if (!unhandled_rejections.empty() &&
    unhandled_rejections != "warn-with-error-code" &&
    unhandled_rejections != "throw" &&
    unhandled_rejections != "strict" &&
    unhandled_rejections != "warn" &&
    unhandled_rejections != "none") {
  errors->push_back("invalid value for --unhandled-rejections");
}

if (tls_min_v1_3 && tls_max_v1_2) {
  errors->push_back("either --tls-min-v1.3 or --tls-max-v1.2 can be "
                    "used, not both");
}

if (heap_snapshot_near_heap_limit < 0) {
  errors->push_back("--heap-snapshot-near-heap-limit must not be negative");
}

if (test_runner) {
  if (syntax_check_only) {
    errors->push_back("either --test or --check can be used, not both");
  }

  if (has_eval_string) {
    errors->push_back("either --test or --eval can be used, not both");
  }

  if (force_repl) {
    errors->push_back("either --test or --interactive can be used, not both");
  }

  if (debug_options_.inspector_enabled) {
    errors->push_back("the inspector cannot be used with --test");
  }
}

164#if HAVE_INSPECTOR1
if (!cpu_prof) {
  if (!cpu_prof_name.empty()) {
    errors->push_back("--cpu-prof-name must be used with --cpu-prof");
  }
  if (!cpu_prof_dir.empty()) {
    errors->push_back("--cpu-prof-dir must be used with --cpu-prof");
  }
  // We can't catch the case where the value passed is the default value,
  // then the option just becomes a noop which is fine.
  if (cpu_prof_interval != kDefaultCpuProfInterval) {
    errors->push_back("--cpu-prof-interval must be used with --cpu-prof");
  }
}

if (cpu_prof && cpu_prof_dir.empty() && !diagnostic_dir.empty()) {
    cpu_prof_dir = diagnostic_dir;
  }

if (!heap_prof) {
  if (!heap_prof_name.empty()) {
    errors->push_back("--heap-prof-name must be used with --heap-prof");
  }
  if (!heap_prof_dir.empty()) {
    errors->push_back("--heap-prof-dir must be used with --heap-prof");
  }
  // We can't catch the case where the value passed is the default value,
  // then the option just becomes a noop which is fine.
  if (heap_prof_interval != kDefaultHeapProfInterval) {
    errors->push_back("--heap-prof-interval must be used with --heap-prof");
  }
}

if (heap_prof && heap_prof_dir.empty() && !diagnostic_dir.empty()) {
  heap_prof_dir = diagnostic_dir;
}

debug_options_.CheckOptions(errors);
202#endif  // HAVE_INSPECTOR
203}

205namespace options_parser {

207class DebugOptionsParser : public OptionsParser<DebugOptions> {
public:
DebugOptionsParser();
210};

212class EnvironmentOptionsParser : public OptionsParser<EnvironmentOptions> {
public:
EnvironmentOptionsParser();
explicit EnvironmentOptionsParser(const DebugOptionsParser& dop)
  : EnvironmentOptionsParser() {
  Insert(dop, &EnvironmentOptions::get_debug_options);
}
219};

221class PerIsolateOptionsParser : public OptionsParser<PerIsolateOptions> {
public:
PerIsolateOptionsParser() = delete;
explicit PerIsolateOptionsParser(const EnvironmentOptionsParser& eop);
225};

227class PerProcessOptionsParser : public OptionsParser<PerProcessOptions> {
public:
PerProcessOptionsParser() = delete;
explicit PerProcessOptionsParser(const PerIsolateOptionsParser& iop);
231};

233#if HAVE_INSPECTOR1
234const DebugOptionsParser _dop_instance{};
235const EnvironmentOptionsParser _eop_instance{_dop_instance};

237// This Parse is not dead code. It is used by embedders (e.g., Electron).
238template <>
239void Parse(
StringVector* const args, StringVector* const exec_args,
StringVector* const v8_args,
DebugOptions* const options,
OptionEnvvarSettings required_env_settings, StringVector* const errors) {
_dop_instance.Parse(
  args, exec_args, v8_args, options, required_env_settings, errors);
246}
247#else
248const EnvironmentOptionsParser _eop_instance{};
249#endif  // HAVE_INSPECTOR
250const PerIsolateOptionsParser _piop_instance{_eop_instance};
251const PerProcessOptionsParser _ppop_instance{_piop_instance};

253template <>
254void Parse(
StringVector* const args, StringVector* const exec_args,
StringVector* const v8_args,
PerIsolateOptions* const options,
OptionEnvvarSettings required_env_settings, StringVector* const errors) {
_piop_instance.Parse(
  args, exec_args, v8_args, options, required_env_settings, errors);
261}

263template <>
264void Parse(
StringVector* const args, StringVector* const exec_args,
StringVector* const v8_args,
PerProcessOptions* const options,
OptionEnvvarSettings required_env_settings, StringVector* const errors) {
_ppop_instance.Parse(
  args, exec_args, v8_args, options, required_env_settings, errors);
271}

273// XXX: If you add an option here, please also add it to doc/node.1 and
274// doc/api/cli.md
275// TODO(addaleax): Make that unnecessary.

277DebugOptionsParser::DebugOptionsParser() {
AddOption("--inspect-port",
          "set host:port for inspector",
          &DebugOptions::host_port,
          kAllowedInEnvironment);
AddAlias("--debug-port", "--inspect-port");

AddOption("--inspect",
          "activate inspector on host:port (default: 127.0.0.1:9229)",
          &DebugOptions::inspector_enabled,
          kAllowedInEnvironment);
AddAlias("--inspect=", { "--inspect-port", "--inspect" });

AddOption("--debug", "", &DebugOptions::deprecated_debug);
AddAlias("--debug=", "--debug");
AddOption("--debug-brk", "", &DebugOptions::deprecated_debug);
AddAlias("--debug-brk=", "--debug-brk");

AddOption("--inspect-brk",
          "activate inspector on host:port and break at start of user script",
          &DebugOptions::break_first_line,
          kAllowedInEnvironment);
Implies("--inspect-brk", "--inspect");
AddAlias("--inspect-brk=", { "--inspect-port", "--inspect-brk" });

AddOption("--inspect-brk-node", "", &DebugOptions::break_node_first_line);
Implies("--inspect-brk-node", "--inspect");
AddAlias("--inspect-brk-node=", { "--inspect-port", "--inspect-brk-node" });

AddOption("--inspect-publish-uid",
          "comma separated list of destinations for inspector uid"
          "(default: stderr,http)",
          &DebugOptions::inspect_publish_uid_string,
          kAllowedInEnvironment);
311}

313EnvironmentOptionsParser::EnvironmentOptionsParser() {
AddOption("--conditions",
          "additional user conditions for conditional exports and imports",
          &EnvironmentOptions::conditions,
          kAllowedInEnvironment);
AddAlias("-C", "--conditions");
AddOption("--diagnostic-dir",
          "set dir for all output files"
          " (default: current working directory)",
          &EnvironmentOptions::diagnostic_dir,
          kAllowedInEnvironment);
AddOption("--dns-result-order",
          "set default value of verbatim in dns.lookup. Options are "
          "'ipv4first' (IPv4 addresses are placed before IPv6 addresses) "
          "'verbatim' (addresses are in the order the DNS resolver "
          "returned)",
          &EnvironmentOptions::dns_result_order,
          kAllowedInEnvironment);
AddOption("--enable-source-maps",
          "Source Map V3 support for stack traces",
          &EnvironmentOptions::enable_source_maps,
          kAllowedInEnvironment);
AddOption("--experimental-abortcontroller", "",
          NoOp{}, kAllowedInEnvironment);
AddOption("--experimental-fetch",
          "experimental Fetch API",
          &EnvironmentOptions::experimental_fetch,
          kAllowedInEnvironment,
          true);
AddOption("--experimental-global-webcrypto",
          "expose experimental Web Crypto API on the global scope",
          &EnvironmentOptions::experimental_global_web_crypto,
          kAllowedInEnvironment);
AddOption("--experimental-json-modules", "", NoOp{}, kAllowedInEnvironment);
AddOption("--experimental-loader",
          "use the specified module as a custom loader",
          &EnvironmentOptions::userland_loaders,
          kAllowedInEnvironment);
AddAlias("--loader", "--experimental-loader");
AddOption("--experimental-modules", "", NoOp{}, kAllowedInEnvironment);
AddOption("--experimental-network-imports",
          "experimental https: support for the ES Module loader",
          &EnvironmentOptions::experimental_https_modules,
          kAllowedInEnvironment);
AddOption("--experimental-wasm-modules",
          "experimental ES Module support for webassembly modules",
          &EnvironmentOptions::experimental_wasm_modules,
          kAllowedInEnvironment);
AddOption("--experimental-import-meta-resolve",
          "experimental ES Module import.meta.resolve() support",
          &EnvironmentOptions::experimental_import_meta_resolve,
          kAllowedInEnvironment);
AddOption("--experimental-policy",
          "use the specified file as a "
          "security policy",
          &EnvironmentOptions::experimental_policy,
          kAllowedInEnvironment);
AddOption("[has_policy_integrity_string]",
          "",
          &EnvironmentOptions::has_policy_integrity_string);
AddOption("--policy-integrity",
          "ensure the security policy contents match "
          "the specified integrity",
          &EnvironmentOptions::experimental_policy_integrity,
          kAllowedInEnvironment);
Implies("--policy-integrity", "[has_policy_integrity_string]");
AddOption("--experimental-repl-await",
          "experimental await keyword support in REPL",
          &EnvironmentOptions::experimental_repl_await,
          kAllowedInEnvironment,
          true);
AddOption("--experimental-vm-modules",
          "experimental ES Module support in vm module",
          &EnvironmentOptions::experimental_vm_modules,
          kAllowedInEnvironment);
AddOption("--experimental-worker", "", NoOp{}, kAllowedInEnvironment);
AddOption("--experimental-report", "", NoOp{}, kAllowedInEnvironment);
AddOption("--experimental-wasi-unstable-preview1",
          "experimental WASI support",
          &EnvironmentOptions::experimental_wasi,
          kAllowedInEnvironment);
AddOption("--expose-internals", "", &EnvironmentOptions::expose_internals);
AddOption("--frozen-intrinsics",
          "experimental frozen intrinsics support",
          &EnvironmentOptions::frozen_intrinsics,
          kAllowedInEnvironment);
AddOption("--heapsnapshot-signal",
          "Generate heap snapshot on specified signal",
          &EnvironmentOptions::heap_snapshot_signal,
          kAllowedInEnvironment);
AddOption("--heapsnapshot-near-heap-limit",
          "Generate heap snapshots whenever V8 is approaching "
          "the heap limit. No more than the specified number of "
          "heap snapshots will be generated.",
          &EnvironmentOptions::heap_snapshot_near_heap_limit,
          kAllowedInEnvironment);
AddOption("--http-parser", "", NoOp{}, kAllowedInEnvironment);
AddOption("--insecure-http-parser",
          "use an insecure HTTP parser that accepts invalid HTTP headers",
          &EnvironmentOptions::insecure_http_parser,
          kAllowedInEnvironment);
AddOption("--input-type",
          "set module type for string input",
          &EnvironmentOptions::module_type,
          kAllowedInEnvironment);
AddOption("--experimental-specifier-resolution",
          "Select extension resolution algorithm for es modules; "
          "either 'explicit' (default) or 'node'",
          &EnvironmentOptions::experimental_specifier_resolution,
          kAllowedInEnvironment);
AddAlias("--es-module-specifier-resolution",
         "--experimental-specifier-resolution");
AddOption("--deprecation",
          "silence deprecation warnings",
          &EnvironmentOptions::deprecation,
          kAllowedInEnvironment,
          true);
AddOption("--force-async-hooks-checks",
          "disable checks for async_hooks",
          &EnvironmentOptions::force_async_hooks_checks,
          kAllowedInEnvironment,
          true);
AddOption(
    "--force-node-api-uncaught-exceptions-policy",
    "enforces 'uncaughtException' event on Node API asynchronous callbacks",
    &EnvironmentOptions::force_node_api_uncaught_exceptions_policy,
    kAllowedInEnvironment,
    false);
AddOption("--addons",
          "disable loading native addons",
          &EnvironmentOptions::allow_native_addons,
          kAllowedInEnvironment,
          true);
AddOption("--global-search-paths",
          "disable global module search paths",
          &EnvironmentOptions::global_search_paths,
          kAllowedInEnvironment,
          true);
AddOption("--warnings",
          "silence all process warnings",
          &EnvironmentOptions::warnings,
          kAllowedInEnvironment,
          true);
AddOption("--force-context-aware",
          "disable loading non-context-aware addons",
          &EnvironmentOptions::force_context_aware,
          kAllowedInEnvironment);
AddOption("--pending-deprecation",
          "emit pending deprecation warnings",
          &EnvironmentOptions::pending_deprecation,
          kAllowedInEnvironment);
AddOption("--preserve-symlinks",
          "preserve symbolic links when resolving",
          &EnvironmentOptions::preserve_symlinks,
          kAllowedInEnvironment);
AddOption("--preserve-symlinks-main",
          "preserve symbolic links when resolving the main module",
          &EnvironmentOptions::preserve_symlinks_main,
          kAllowedInEnvironment);
AddOption("--prof",
          "Generate V8 profiler output.",
          V8Option{});
AddOption("--prof-process",
          "process V8 profiler output generated using --prof",
          &EnvironmentOptions::prof_process);
// Options after --prof-process are passed through to the prof processor.
AddAlias("--prof-process", { "--prof-process", "--" });
480#if HAVE_INSPECTOR1
AddOption("--cpu-prof",
          "Start the V8 CPU profiler on start up, and write the CPU profile "
          "to disk before exit. If --cpu-prof-dir is not specified, write "
          "the profile to the current working directory.",
          &EnvironmentOptions::cpu_prof);
AddOption("--cpu-prof-name",
          "specified file name of the V8 CPU profile generated with "
          "--cpu-prof",
          &EnvironmentOptions::cpu_prof_name);
AddOption("--cpu-prof-interval",
          "specified sampling interval in microseconds for the V8 CPU "
          "profile generated with --cpu-prof. (default: 1000)",
          &EnvironmentOptions::cpu_prof_interval);
AddOption("--cpu-prof-dir",
          "Directory where the V8 profiles generated by --cpu-prof will be "
          "placed. Does not affect --prof.",
          &EnvironmentOptions::cpu_prof_dir);
AddOption(
    "--heap-prof",
    "Start the V8 heap profiler on start up, and write the heap profile "
    "to disk before exit. If --heap-prof-dir is not specified, write "
    "the profile to the current working directory.",
    &EnvironmentOptions::heap_prof);
AddOption("--heap-prof-name",
          "specified file name of the V8 heap profile generated with "
          "--heap-prof",
          &EnvironmentOptions::heap_prof_name);
AddOption("--heap-prof-dir",
          "Directory where the V8 heap profiles generated by --heap-prof "
          "will be placed.",
          &EnvironmentOptions::heap_prof_dir);
AddOption("--heap-prof-interval",
          "specified sampling interval in bytes for the V8 heap "
          "profile generated with --heap-prof. (default: 512 * 1024)",
          &EnvironmentOptions::heap_prof_interval);
516#endif  // HAVE_INSPECTOR
AddOption("--max-http-header-size",
          "set the maximum size of HTTP headers (default: 16384 (16KB))",
          &EnvironmentOptions::max_http_header_size,
          kAllowedInEnvironment);
AddOption("--redirect-warnings",
          "write warnings to file instead of stderr",
          &EnvironmentOptions::redirect_warnings,
          kAllowedInEnvironment);
AddOption("--test",
          "launch test runner on startup",
          &EnvironmentOptions::test_runner);
AddOption("--test-only",
          "run tests with 'only' option set",
          &EnvironmentOptions::test_only,
          kAllowedInEnvironment);
AddOption("--test-udp-no-try-send", "",  // For testing only.
          &EnvironmentOptions::test_udp_no_try_send);
AddOption("--throw-deprecation",
          "throw an exception on deprecations",
          &EnvironmentOptions::throw_deprecation,
          kAllowedInEnvironment);
AddOption("--trace-atomics-wait",
          "trace Atomics.wait() operations",
          &EnvironmentOptions::trace_atomics_wait,
          kAllowedInEnvironment);
AddOption("--trace-deprecation",
          "show stack traces on deprecations",
          &EnvironmentOptions::trace_deprecation,
          kAllowedInEnvironment);
AddOption("--trace-exit",
          "show stack trace when an environment exits",
          &EnvironmentOptions::trace_exit,
          kAllowedInEnvironment);
AddOption("--trace-sync-io",
          "show stack trace when use of sync IO is detected after the "
          "first tick",
          &EnvironmentOptions::trace_sync_io,
          kAllowedInEnvironment);
AddOption("--trace-tls",
          "prints TLS packet trace information to stderr",
          &EnvironmentOptions::trace_tls,
          kAllowedInEnvironment);
AddOption("--trace-uncaught",
          "show stack traces for the `throw` behind uncaught exceptions",
          &EnvironmentOptions::trace_uncaught,
          kAllowedInEnvironment);
AddOption("--trace-warnings",
          "show stack traces on process warnings",
          &EnvironmentOptions::trace_warnings,
          kAllowedInEnvironment);
AddOption("--extra-info-on-fatal-exception",
          "hide extra information on fatal exception that causes exit",
          &EnvironmentOptions::extra_info_on_fatal_exception,
          kAllowedInEnvironment,
          true);
AddOption("--unhandled-rejections",
          "define unhandled rejections behavior. Options are 'strict' "
          "(always raise an error), 'throw' (raise an error unless "
          "'unhandledRejection' hook is set), 'warn' (log a warning), 'none' "
          "(silence warnings), 'warn-with-error-code' (log a warning and set "
          "exit code 1 unless 'unhandledRejection' hook is set). (default: "
          "throw)",
          &EnvironmentOptions::unhandled_rejections,
          kAllowedInEnvironment);
AddOption("--verify-base-objects",
          "", /* undocumented, only for debugging */
          &EnvironmentOptions::verify_base_objects,
          kAllowedInEnvironment);

AddOption("--check",
          "syntax check script without executing",
          &EnvironmentOptions::syntax_check_only);
AddAlias("-c", "--check");
// This option is only so that we can tell --eval with an empty string from
// no eval at all. Having it not start with a dash makes it inaccessible
// from the parser itself, but available for using Implies().
// TODO(addaleax): When moving --help over to something generated from the
// programmatic descriptions, this will need some special care.
// (See also [ssl_openssl_cert_store] below.)
AddOption("[has_eval_string]", "", &EnvironmentOptions::has_eval_string);
AddOption("--eval", "evaluate script", &EnvironmentOptions::eval_string);
Implies("--eval", "[has_eval_string]");
AddOption("--print",
          "evaluate script and print result",
          &EnvironmentOptions::print_eval);
AddAlias("-e", "--eval");
AddAlias("--print <arg>", "-pe");
AddAlias("-pe", { "--print", "--eval" });
AddAlias("-p", "--print");
AddOption("--require",
          "module to preload (option can be repeated)",
          &EnvironmentOptions::preload_modules,
          kAllowedInEnvironment);
AddAlias("-r", "--require");
AddOption("--interactive",
          "always enter the REPL even if stdin does not appear "
          "to be a terminal",
          &EnvironmentOptions::force_repl);
AddAlias("-i", "--interactive");

AddOption("--napi-modules", "", NoOp{}, kAllowedInEnvironment);

AddOption("--tls-keylog",
          "log TLS decryption keys to named file for traffic analysis",
          &EnvironmentOptions::tls_keylog, kAllowedInEnvironment);

AddOption("--tls-min-v1.0",
          "set default TLS minimum to TLSv1.0 (default: TLSv1.2)",
          &EnvironmentOptions::tls_min_v1_0,
          kAllowedInEnvironment);
AddOption("--tls-min-v1.1",
          "set default TLS minimum to TLSv1.1 (default: TLSv1.2)",
          &EnvironmentOptions::tls_min_v1_1,
          kAllowedInEnvironment);
AddOption("--tls-min-v1.2",
          "set default TLS minimum to TLSv1.2 (default: TLSv1.2)",
          &EnvironmentOptions::tls_min_v1_2,
          kAllowedInEnvironment);
AddOption("--tls-min-v1.3",
          "set default TLS minimum to TLSv1.3 (default: TLSv1.2)",
          &EnvironmentOptions::tls_min_v1_3,
          kAllowedInEnvironment);
AddOption("--tls-max-v1.2",
          "set default TLS maximum to TLSv1.2 (default: TLSv1.3)",
          &EnvironmentOptions::tls_max_v1_2,
          kAllowedInEnvironment);
// Current plan is:
// - 11.x and below: TLS1.3 is opt-in with --tls-max-v1.3
// - 12.x: TLS1.3 is opt-out with --tls-max-v1.2
// In either case, support both options they are uniformly available.
AddOption("--tls-max-v1.3",
          "set default TLS maximum to TLSv1.3 (default: TLSv1.3)",
          &EnvironmentOptions::tls_max_v1_3,
          kAllowedInEnvironment);
651}

653PerIsolateOptionsParser::PerIsolateOptionsParser(
const EnvironmentOptionsParser& eop) {
AddOption("--track-heap-objects",
          "track heap object allocations for heap snapshots",
          &PerIsolateOptions::track_heap_objects,
          kAllowedInEnvironment);

// Explicitly add some V8 flags to mark them as allowed in NODE_OPTIONS.
AddOption("--abort-on-uncaught-exception",
          "aborting instead of exiting causes a core file to be generated "
          "for analysis",
          V8Option{},
          kAllowedInEnvironment);
AddOption("--interpreted-frames-native-stack",
          "help system profilers to translate JavaScript interpreted frames",
          V8Option{}, kAllowedInEnvironment);
AddOption("--max-old-space-size", "", V8Option{}, kAllowedInEnvironment);
AddOption("--perf-basic-prof", "", V8Option{}, kAllowedInEnvironment);
AddOption("--perf-basic-prof-only-functions",
          "",
          V8Option{},
          kAllowedInEnvironment);
AddOption("--perf-prof", "", V8Option{}, kAllowedInEnvironment);
AddOption("--perf-prof-unwinding-info",
          "",
          V8Option{},
          kAllowedInEnvironment);
AddOption("--stack-trace-limit", "", V8Option{}, kAllowedInEnvironment);
AddOption("--disallow-code-generation-from-strings",
          "disallow eval and friends",
          V8Option{},
          kAllowedInEnvironment);
AddOption("--huge-max-old-generation-size",
           "increase default maximum heap size on machines with 16GB memory "
           "or more",
           V8Option{},
           kAllowedInEnvironment);
AddOption("--jitless",
           "disable runtime allocation of executable memory",
           V8Option{},
           kAllowedInEnvironment);
AddOption("--report-uncaught-exception",
          "generate diagnostic report on uncaught exceptions",
          &PerIsolateOptions::report_uncaught_exception,
          kAllowedInEnvironment);
AddOption("--report-on-signal",
          "generate diagnostic report upon receiving signals",
          &PerIsolateOptions::report_on_signal,
          kAllowedInEnvironment);
AddOption("--report-signal",
          "causes diagnostic report to be produced on provided signal,"
          " unsupported in Windows. (default: SIGUSR2)",
          &PerIsolateOptions::report_signal,
          kAllowedInEnvironment);
Implies("--report-signal", "--report-on-signal");

AddOption(
    "--experimental-top-level-await", "", NoOp{}, kAllowedInEnvironment);

Insert(eop, &PerIsolateOptions::get_per_env_options);
1
Calling 'OptionsParser::Insert'→
713}

715PerProcessOptionsParser::PerProcessOptionsParser(
const PerIsolateOptionsParser& iop) {
AddOption("--title",
          "the process title to use on startup",
          &PerProcessOptions::title,
          kAllowedInEnvironment);
AddOption("--trace-event-categories",
          "comma separated list of trace event categories to record",
          &PerProcessOptions::trace_event_categories,
          kAllowedInEnvironment);
AddOption("--trace-event-file-pattern",
          "Template string specifying the filepath for the trace-events "
          "data, it supports ${rotation} and ${pid}.",
          &PerProcessOptions::trace_event_file_pattern,
          kAllowedInEnvironment);
AddAlias("--trace-events-enabled", {
  "--trace-event-categories", "v8,node,node.async_hooks" });
AddOption("--v8-pool-size",
          "set V8's thread pool size",
          &PerProcessOptions::v8_thread_pool_size,
          kAllowedInEnvironment);
AddOption("--zero-fill-buffers",
          "automatically zero-fill all newly allocated Buffer and "
          "SlowBuffer instances",
          &PerProcessOptions::zero_fill_all_buffers,
          kAllowedInEnvironment);
AddOption("--debug-arraybuffer-allocations",
          "", /* undocumented, only for debugging */
          &PerProcessOptions::debug_arraybuffer_allocations,
          kAllowedInEnvironment);
AddOption("--disable-proto",
          "disable Object.prototype.__proto__",
          &PerProcessOptions::disable_proto,
          kAllowedInEnvironment);
AddOption("--build-snapshot",
          "Generate a snapshot blob when the process exits."
          "Currently only supported in the node_mksnapshot binary.",
          &PerProcessOptions::build_snapshot,
          kDisallowedInEnvironment);
AddOption("--node-snapshot",
          "",  // It's a debug-only option.
          &PerProcessOptions::node_snapshot,
          kAllowedInEnvironment);
// 12.x renamed this inadvertently, so alias it for consistency within the
// release line, while using the original name for consistency with older
// release lines.
AddOption("--security-revert", "", &PerProcessOptions::security_reverts);
AddAlias("--security-reverts", "--security-revert");
AddOption("--completion-bash",
          "print source-able bash completion script",
          &PerProcessOptions::print_bash_completion);
AddOption("--help",
          "print node command line options",
          &PerProcessOptions::print_help);
AddAlias("-h", "--help");
AddOption(
    "--version", "print Node.js version", &PerProcessOptions::print_version);
AddAlias("-v", "--version");
AddOption("--v8-options",
          "print V8 command line options",
          &PerProcessOptions::print_v8_help);
AddOption("--report-compact",
          "output compact single-line JSON",
          &PerProcessOptions::report_compact,
          kAllowedInEnvironment);
AddOption("--report-dir",
          "define custom report pathname."
          " (default: current working directory)",
          &PerProcessOptions::report_directory,
          kAllowedInEnvironment);
AddAlias("--report-directory", "--report-dir");
AddOption("--report-filename",
          "define custom report file name."
          " (default: YYYYMMDD.HHMMSS.PID.SEQUENCE#.txt)",
          &PerProcessOptions::report_filename,
          kAllowedInEnvironment);
AddOption("--report-on-fatalerror",
            "generate diagnostic report on fatal (internal) errors",
            &PerProcessOptions::report_on_fatalerror,
            kAllowedInEnvironment);

796#ifdef NODE_HAVE_I18N_SUPPORT1
AddOption("--icu-data-dir",
          "set ICU data load path to dir (overrides NODE_ICU_DATA)"
799#ifndef NODE_HAVE_SMALL_ICU
          " (note: linked-in ICU data is present)"
801#endif
          ,
          &PerProcessOptions::icu_data_dir,
          kAllowedInEnvironment);
805#endif

807#if HAVE_OPENSSL1
AddOption("--openssl-config",
          "load OpenSSL configuration from the specified file "
          "(overrides OPENSSL_CONF)",
          &PerProcessOptions::openssl_config,
          kAllowedInEnvironment);
AddOption("--tls-cipher-list",
          "use an alternative default TLS cipher list",
          &PerProcessOptions::tls_cipher_list,
          kAllowedInEnvironment);
AddOption("--use-openssl-ca",
          "use OpenSSL's default CA store"
819#if defined(NODE_OPENSSL_CERT_STORE)
          " (default)"
821#endif
          ,
          &PerProcessOptions::use_openssl_ca,
          kAllowedInEnvironment);
AddOption("--use-bundled-ca",
          "use bundled CA store"
827#if !defined(NODE_OPENSSL_CERT_STORE)
          " (default)"
829#endif
          ,
          &PerProcessOptions::use_bundled_ca,
          kAllowedInEnvironment);
// Similar to [has_eval_string] above, except that the separation between
// this and use_openssl_ca only exists for option validation after parsing.
// This is not ideal.
AddOption("[ssl_openssl_cert_store]",
          "",
          &PerProcessOptions::ssl_openssl_cert_store);
Implies("--use-openssl-ca", "[ssl_openssl_cert_store]");
ImpliesNot("--use-bundled-ca", "[ssl_openssl_cert_store]");
AddOption("--enable-fips",
          "enable FIPS crypto at startup",
          &PerProcessOptions::enable_fips_crypto,
          kAllowedInEnvironment);
AddOption("--force-fips",
          "force FIPS crypto (cannot be disabled)",
          &PerProcessOptions::force_fips_crypto,
          kAllowedInEnvironment);
AddOption("--secure-heap",
          "total size of the OpenSSL secure heap",
          &PerProcessOptions::secure_heap,
          kAllowedInEnvironment);
AddOption("--secure-heap-min",
          "minimum allocation size from the OpenSSL secure heap",
          &PerProcessOptions::secure_heap_min,
          kAllowedInEnvironment);
857#endif  // HAVE_OPENSSL
858#if OPENSSL_VERSION_MAJOR3 >= 3
AddOption("--openssl-legacy-provider",
          "enable OpenSSL 3.0 legacy provider",
          &PerProcessOptions::openssl_legacy_provider,
          kAllowedInEnvironment);
AddOption("--openssl-shared-config",
          "enable OpenSSL shared configuration",
          &PerProcessOptions::openssl_shared_config,
          kAllowedInEnvironment);

868#endif  // OPENSSL_VERSION_MAJOR
AddOption("--use-largepages",
          "Map the Node.js static code to large pages. Options are "
          "'off' (the default value, meaning do not map), "
          "'on' (map and ignore failure, reporting it to stderr), "
          "or 'silent' (map and silently ignore failure)",
          &PerProcessOptions::use_largepages,
          kAllowedInEnvironment);

AddOption("--trace-sigint",
          "enable printing JavaScript stacktrace on SIGINT",
          &PerProcessOptions::trace_sigint,
          kAllowedInEnvironment);

Insert(iop, &PerProcessOptions::get_per_isolate_options);

AddOption("--node-memory-debug",
          "Run with extra debug checks for memory leaks in Node.js itself",
          NoOp{}, kAllowedInEnvironment);
Implies("--node-memory-debug", "--debug-arraybuffer-allocations");
Implies("--node-memory-debug", "--verify-base-objects");
889}

891inline std::string RemoveBrackets(const std::string& host) {
if (!host.empty() && host.front() == '[' && host.back() == ']')
  return host.substr(1, host.size() - 2);
else
  return host;
896}

898inline int ParseAndValidatePort(const std::string& port,
                              std::vector<std::string>* errors) {
char* endptr;
errno(*__errno_location ()) = 0;
const unsigned long result =                 // NOLINT(runtime/int)
  strtoul(port.c_str(), &endptr, 10);
if (errno(*__errno_location ()) != 0 || *endptr != '\0'||
    (result != 0 && result < 1024) || result > 65535) {
  errors->push_back(" must be 0 or in range 1024 to 65535.");
}
return static_cast<int>(result);
909}

911HostPort SplitHostPort(const std::string& arg,
                    std::vector<std::string>* errors) {
// remove_brackets only works if no port is specified
// so if it has an effect only an IPv6 address was specified.
std::string host = RemoveBrackets(arg);
if (host.length() < arg.length())
  return HostPort{host, DebugOptions::kDefaultInspectorPort};

size_t colon = arg.rfind(':');
if (colon == std::string::npos) {
  // Either a port number or a host name.  Assume that
  // if it's not all decimal digits, it's a host name.
  for (char c : arg) {
    if (c < '0' || c > '9') {
      return HostPort{arg, DebugOptions::kDefaultInspectorPort};
    }
  }
  return HostPort { "", ParseAndValidatePort(arg, errors) };
}
// Host and port found:
return HostPort { RemoveBrackets(arg.substr(0, colon)),
                  ParseAndValidatePort(arg.substr(colon + 1), errors) };
933}

935std::string GetBashCompletion() {
Mutex::ScopedLock lock(per_process::cli_options_mutex);
const auto& parser = _ppop_instance;

std::ostringstream out;

out << "_node_complete() {\n"
       "  local cur_word options\n"
       "  cur_word=\"${COMP_WORDS[COMP_CWORD]}\"\n"
       "  if [[ \"${cur_word}\" == -* ]] ; then\n"
       "    COMPREPLY=( $(compgen -W '";

for (const auto& item : parser.options_) {
  if (item.first[0] != '[') {
    out << item.first << " ";
  }
}
for (const auto& item : parser.aliases_) {
  if (item.first[0] != '[') {
    out << item.first << " ";
  }
}
if (parser.aliases_.size() > 0) {
  out.seekp(-1, out.cur);  // Strip the trailing space
}

out << "' -- \"${cur_word}\") )\n"
       "    return 0\n"
       "  else\n"
       "    COMPREPLY=( $(compgen -f \"${cur_word}\") )\n"
       "    return 0\n"
       "  fi\n"
       "}\n"
       "complete -o filenames -o nospace -o bashdefault "
       "-F _node_complete node node_g";
return out.str();
971}

973// Return a map containing all the options and their metadata as well
974// as the aliases
975void GetCLIOptions(const FunctionCallbackInfo<Value>& args) {
Mutex::ScopedLock lock(per_process::cli_options_mutex);
Environment* env = Environment::GetCurrent(args);
if (!env->has_run_bootstrapping_code()) {
  // No code because this is an assertion.
  return env->ThrowError(
      "Should not query options before bootstrapping is done");
}
env->set_has_serialized_options(true);

Isolate* isolate = env->isolate();
Local<Context> context = env->context();

// Temporarily act as if the current Environment's/IsolateData's options were
// the default options, i.e. like they are the ones we'd access for global
// options parsing, so that all options are available from the main parser.
auto original_per_isolate = per_process::cli_options->per_isolate;
per_process::cli_options->per_isolate = env->isolate_data()->options();
auto original_per_env = per_process::cli_options->per_isolate->per_env;
per_process::cli_options->per_isolate->per_env = env->options();
auto on_scope_leave = OnScopeLeave([&]() {
  per_process::cli_options->per_isolate->per_env = original_per_env;
  per_process::cli_options->per_isolate = original_per_isolate;
});

Local<Map> options = Map::New(isolate);
if (options
        ->SetPrototype(context, env->primordials_safe_map_prototype_object())
        .IsNothing()) {
  return;
}

for (const auto& item : _ppop_instance.options_) {
  Local<Value> value;
  const auto& option_info = item.second;
  auto field = option_info.field;
  PerProcessOptions* opts = per_process::cli_options.get();
  switch (option_info.type) {
    case kNoOp:
    case kV8Option:
      // Special case for --abort-on-uncaught-exception which is also
      // respected by Node.js internals
      if (item.first == "--abort-on-uncaught-exception") {
        value = Boolean::New(
          isolate, original_per_env->abort_on_uncaught_exception);
      } else {
        value = Undefined(isolate);
      }
      break;
    case kBoolean:
      value = Boolean::New(isolate,
                           *_ppop_instance.Lookup<bool>(field, opts));
      break;
    case kInteger:
      value = Number::New(
          isolate,
          static_cast<double>(*_ppop_instance.Lookup<int64_t>(field, opts)));
      break;
    case kUInteger:
      value = Number::New(
          isolate,
          static_cast<double>(*_ppop_instance.Lookup<uint64_t>(field, opts)));
      break;
    case kString:
      if (!ToV8Value(context,
                     *_ppop_instance.Lookup<std::string>(field, opts))
               .ToLocal(&value)) {
        return;
      }
      break;
    case kStringList:
      if (!ToV8Value(context,
                     *_ppop_instance.Lookup<StringVector>(field, opts))
               .ToLocal(&value)) {
        return;
      }
      break;
    case kHostPort: {
      const HostPort& host_port =
        *_ppop_instance.Lookup<HostPort>(field, opts);
      Local<Object> obj = Object::New(isolate);
      Local<Value> host;
      if (!ToV8Value(context, host_port.host()).ToLocal(&host) ||
          obj->Set(context, env->host_string(), host).IsNothing() ||
          obj->Set(context,
                   env->port_string(),
                   Integer::New(isolate, host_port.port()))
              .IsNothing()) {
        return;
      }
      value = obj;
      break;
    }
    default:
      UNREACHABLE()do { static const node::AssertionInfo args = { "../src/node_options.cc"
 ":" "1069", "\"Unreachable code reached\"", __PRETTY_FUNCTION__
 }; node::Assert(args); } while (0);
  }
  CHECK(!value.IsEmpty())do { if (__builtin_expect(!!(!(!value.IsEmpty())), 0)) { do {
 static const node::AssertionInfo args = { "../src/node_options.cc"
 ":" "1071", "!value.IsEmpty()", __PRETTY_FUNCTION__ }; node::
Assert(args); } while (0); } } while (0);

  Local<Value> name = ToV8Value(context, item.first).ToLocalChecked();
  Local<Object> info = Object::New(isolate);
  Local<Value> help_text;
  if (!ToV8Value(context, option_info.help_text).ToLocal(&help_text) ||
      !info->Set(context, env->help_text_string(), help_text)
           .FromMaybe(false) ||
      !info->Set(context,
                 env->env_var_settings_string(),
                 Integer::New(isolate,
                              static_cast<int>(option_info.env_setting)))
           .FromMaybe(false) ||
      !info->Set(context,
                 env->type_string(),
                 Integer::New(isolate, static_cast<int>(option_info.type)))
           .FromMaybe(false) ||
      !info->Set(context,
                 env->default_is_true_string(),
                 Boolean::New(isolate, option_info.default_is_true))
           .FromMaybe(false) ||
      info->Set(context, env->value_string(), value).IsNothing() ||
      options->Set(context, name, info).IsEmpty()) {
    return;
  }
}

Local<Value> aliases;
if (!ToV8Value(context, _ppop_instance.aliases_).ToLocal(&aliases)) return;

if (aliases.As<Object>()
        ->SetPrototype(context, env->primordials_safe_map_prototype_object())
        .IsNothing()) {
  return;
}

Local<Object> ret = Object::New(isolate);
if (ret->Set(context, env->options_string(), options).IsNothing() ||
    ret->Set(context, env->aliases_string(), aliases).IsNothing()) {
  return;
}

args.GetReturnValue().Set(ret);
1114}

1116void GetEmbedderOptions(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
if (!env->has_run_bootstrapping_code()) {
  // No code because this is an assertion.
  return env->ThrowError(
      "Should not query options before bootstrapping is done");
}
Isolate* isolate = args.GetIsolate();
Local<Context> context = env->context();
Local<Object> ret = Object::New(isolate);

if (ret->Set(context,
         FIXED_ONE_BYTE_STRING(env->isolate(), "shouldNotRegisterESMLoader"),
         Boolean::New(isolate, env->should_not_register_esm_loader()))
    .IsNothing()) return;

if (ret->Set(context,
         FIXED_ONE_BYTE_STRING(env->isolate(), "noGlobalSearchPaths"),
         Boolean::New(isolate, env->no_global_search_paths()))
    .IsNothing()) return;

args.GetReturnValue().Set(ret);
1138}

1140void Initialize(Local<Object> target,
              Local<Value> unused,
              Local<Context> context,
              void* priv) {
Environment* env = Environment::GetCurrent(context);
Isolate* isolate = env->isolate();
env->SetMethodNoSideEffect(target, "getCLIOptions", GetCLIOptions);
env->SetMethodNoSideEffect(target, "getEmbedderOptions", GetEmbedderOptions);

Local<Object> env_settings = Object::New(isolate);
NODE_DEFINE_CONSTANT(env_settings, kAllowedInEnvironment)do { v8::Isolate* isolate = env_settings->GetIsolate(); v8
::Local<v8::Context> context = isolate->GetCurrentContext
(); v8::Local<v8::String> constant_name = v8::String::NewFromUtf8
(isolate, "kAllowedInEnvironment", v8::NewStringType::kInternalized
).ToLocalChecked(); v8::Local<v8::Number> constant_value
 = v8::Number::New(isolate, static_cast<double>(kAllowedInEnvironment
)); v8::PropertyAttribute constant_attributes = static_cast<
v8::PropertyAttribute>(v8::ReadOnly | v8::DontDelete); (env_settings
)->DefineOwnProperty(context, constant_name, constant_value
, constant_attributes).Check(); } while (0);
NODE_DEFINE_CONSTANT(env_settings, kDisallowedInEnvironment)do { v8::Isolate* isolate = env_settings->GetIsolate(); v8
::Local<v8::Context> context = isolate->GetCurrentContext
(); v8::Local<v8::String> constant_name = v8::String::NewFromUtf8
(isolate, "kDisallowedInEnvironment", v8::NewStringType::kInternalized
).ToLocalChecked(); v8::Local<v8::Number> constant_value
 = v8::Number::New(isolate, static_cast<double>(kDisallowedInEnvironment
)); v8::PropertyAttribute constant_attributes = static_cast<
v8::PropertyAttribute>(v8::ReadOnly | v8::DontDelete); (env_settings
)->DefineOwnProperty(context, constant_name, constant_value
, constant_attributes).Check(); } while (0);
target
    ->Set(
        context, FIXED_ONE_BYTE_STRING(isolate, "envSettings"), env_settings)
    .Check();

Local<Object> types = Object::New(isolate);
NODE_DEFINE_CONSTANT(types, kNoOp)do { v8::Isolate* isolate = types->GetIsolate(); v8::Local
<v8::Context> context = isolate->GetCurrentContext()
; v8::Local<v8::String> constant_name = v8::String::NewFromUtf8
(isolate, "kNoOp", v8::NewStringType::kInternalized).ToLocalChecked
(); v8::Local<v8::Number> constant_value = v8::Number::
New(isolate, static_cast<double>(kNoOp)); v8::PropertyAttribute
 constant_attributes = static_cast<v8::PropertyAttribute>
(v8::ReadOnly | v8::DontDelete); (types)->DefineOwnProperty
(context, constant_name, constant_value, constant_attributes)
.Check(); } while (0);
NODE_DEFINE_CONSTANT(types, kV8Option)do { v8::Isolate* isolate = types->GetIsolate(); v8::Local
<v8::Context> context = isolate->GetCurrentContext()
; v8::Local<v8::String> constant_name = v8::String::NewFromUtf8
(isolate, "kV8Option", v8::NewStringType::kInternalized).ToLocalChecked
(); v8::Local<v8::Number> constant_value = v8::Number::
New(isolate, static_cast<double>(kV8Option)); v8::PropertyAttribute
 constant_attributes = static_cast<v8::PropertyAttribute>
(v8::ReadOnly | v8::DontDelete); (types)->DefineOwnProperty
(context, constant_name, constant_value, constant_attributes)
.Check(); } while (0);
NODE_DEFINE_CONSTANT(types, kBoolean)do { v8::Isolate* isolate = types->GetIsolate(); v8::Local
<v8::Context> context = isolate->GetCurrentContext()
; v8::Local<v8::String> constant_name = v8::String::NewFromUtf8
(isolate, "kBoolean", v8::NewStringType::kInternalized).ToLocalChecked
(); v8::Local<v8::Number> constant_value = v8::Number::
New(isolate, static_cast<double>(kBoolean)); v8::PropertyAttribute
 constant_attributes = static_cast<v8::PropertyAttribute>
(v8::ReadOnly | v8::DontDelete); (types)->DefineOwnProperty
(context, constant_name, constant_value, constant_attributes)
.Check(); } while (0);
NODE_DEFINE_CONSTANT(types, kInteger)do { v8::Isolate* isolate = types->GetIsolate(); v8::Local
<v8::Context> context = isolate->GetCurrentContext()
; v8::Local<v8::String> constant_name = v8::String::NewFromUtf8
(isolate, "kInteger", v8::NewStringType::kInternalized).ToLocalChecked
(); v8::Local<v8::Number> constant_value = v8::Number::
New(isolate, static_cast<double>(kInteger)); v8::PropertyAttribute
 constant_attributes = static_cast<v8::PropertyAttribute>
(v8::ReadOnly | v8::DontDelete); (types)->DefineOwnProperty
(context, constant_name, constant_value, constant_attributes)
.Check(); } while (0);
NODE_DEFINE_CONSTANT(types, kUInteger)do { v8::Isolate* isolate = types->GetIsolate(); v8::Local
<v8::Context> context = isolate->GetCurrentContext()
; v8::Local<v8::String> constant_name = v8::String::NewFromUtf8
(isolate, "kUInteger", v8::NewStringType::kInternalized).ToLocalChecked
(); v8::Local<v8::Number> constant_value = v8::Number::
New(isolate, static_cast<double>(kUInteger)); v8::PropertyAttribute
 constant_attributes = static_cast<v8::PropertyAttribute>
(v8::ReadOnly | v8::DontDelete); (types)->DefineOwnProperty
(context, constant_name, constant_value, constant_attributes)
.Check(); } while (0);
NODE_DEFINE_CONSTANT(types, kString)do { v8::Isolate* isolate = types->GetIsolate(); v8::Local
<v8::Context> context = isolate->GetCurrentContext()
; v8::Local<v8::String> constant_name = v8::String::NewFromUtf8
(isolate, "kString", v8::NewStringType::kInternalized).ToLocalChecked
(); v8::Local<v8::Number> constant_value = v8::Number::
New(isolate, static_cast<double>(kString)); v8::PropertyAttribute
 constant_attributes = static_cast<v8::PropertyAttribute>
(v8::ReadOnly | v8::DontDelete); (types)->DefineOwnProperty
(context, constant_name, constant_value, constant_attributes)
.Check(); } while (0);
NODE_DEFINE_CONSTANT(types, kHostPort)do { v8::Isolate* isolate = types->GetIsolate(); v8::Local
<v8::Context> context = isolate->GetCurrentContext()
; v8::Local<v8::String> constant_name = v8::String::NewFromUtf8
(isolate, "kHostPort", v8::NewStringType::kInternalized).ToLocalChecked
(); v8::Local<v8::Number> constant_value = v8::Number::
New(isolate, static_cast<double>(kHostPort)); v8::PropertyAttribute
 constant_attributes = static_cast<v8::PropertyAttribute>
(v8::ReadOnly | v8::DontDelete); (types)->DefineOwnProperty
(context, constant_name, constant_value, constant_attributes)
.Check(); } while (0);
NODE_DEFINE_CONSTANT(types, kStringList)do { v8::Isolate* isolate = types->GetIsolate(); v8::Local
<v8::Context> context = isolate->GetCurrentContext()
; v8::Local<v8::String> constant_name = v8::String::NewFromUtf8
(isolate, "kStringList", v8::NewStringType::kInternalized).ToLocalChecked
(); v8::Local<v8::Number> constant_value = v8::Number::
New(isolate, static_cast<double>(kStringList)); v8::PropertyAttribute
 constant_attributes = static_cast<v8::PropertyAttribute>
(v8::ReadOnly | v8::DontDelete); (types)->DefineOwnProperty
(context, constant_name, constant_value, constant_attributes)
.Check(); } while (0);
target->Set(context, FIXED_ONE_BYTE_STRING(isolate, "types"), types)
    .Check();
1168}

1170void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
registry->Register(GetCLIOptions);
registry->Register(GetEmbedderOptions);
1173}
1174}  // namespace options_parser

1176void HandleEnvOptions(std::shared_ptr<EnvironmentOptions> env_options) {
HandleEnvOptions(env_options, [](const char* name) {
  std::string text;
  return credentials::SafeGetenv(name, &text) ? text : "";
});
1181}

1183void HandleEnvOptions(std::shared_ptr<EnvironmentOptions> env_options,
                    std::function<std::string(const char*)> opt_getter) {
env_options->pending_deprecation =
    opt_getter("NODE_PENDING_DEPRECATION") == "1";

env_options->preserve_symlinks = opt_getter("NODE_PRESERVE_SYMLINKS") == "1";

env_options->preserve_symlinks_main =
    opt_getter("NODE_PRESERVE_SYMLINKS_MAIN") == "1";

if (env_options->redirect_warnings.empty())
  env_options->redirect_warnings = opt_getter("NODE_REDIRECT_WARNINGS");
1195}

1197std::vector<std::string> ParseNodeOptionsEnvVar(
  const std::string& node_options, std::vector<std::string>* errors) {
std::vector<std::string> env_argv;

bool is_in_string = false;
bool will_start_new_arg = true;
for (std::string::size_type index = 0; index < node_options.size(); ++index) {
  char c = node_options.at(index);

  // Backslashes escape the following character
  if (c == '\\' && is_in_string) {
    if (index + 1 == node_options.size()) {
      errors->push_back("invalid value for NODE_OPTIONS "
                        "(invalid escape)\n");
      return env_argv;
    } else {
      c = node_options.at(++index);
    }
  } else if (c == ' ' && !is_in_string) {
    will_start_new_arg = true;
    continue;
  } else if (c == '"') {
    is_in_string = !is_in_string;
    continue;
  }

  if (will_start_new_arg) {
    env_argv.emplace_back(std::string(1, c));
    will_start_new_arg = false;
  } else {
    env_argv.back() += c;
  }
}

if (is_in_string) {
  errors->push_back("invalid value for NODE_OPTIONS "
                    "(unterminated string)\n");
}
return env_argv;
1236}
1237}  // namespace node

1239NODE_MODULE_CONTEXT_AWARE_INTERNAL(options, node::options_parser::Initialize)static node::node_module _module = { 108, NM_F_INTERNAL, nullptr
, "../src/node_options.cc", nullptr, (node::addon_context_register_func
)(node::options_parser::Initialize), "options", nullptr, nullptr
}; void _register_options() { node_module_register(&_module
); }
1240NODE_MODULE_EXTERNAL_REFERENCE(options,void _register_external_reference_options( node::ExternalReferenceRegistry
* registry) { node::options_parser::RegisterExternalReferences
(registry); }
                             node::options_parser::RegisterExternalReferences)void _register_external_reference_options( node::ExternalReferenceRegistry
* registry) { node::options_parser::RegisterExternalReferences
(registry); }

←

../src/node_options-inl.h

→

1#ifndef SRC_NODE_OPTIONS_INL_H_
2#define SRC_NODE_OPTIONS_INL_H_

4#if defined(NODE_WANT_INTERNALS1) && NODE_WANT_INTERNALS1

6#include <cstdlib>
7#include "node_options.h"
8#include "util.h"

10namespace node {

12PerIsolateOptions* PerProcessOptions::get_per_isolate_options() {
return per_isolate.get();
14}

16EnvironmentOptions* PerIsolateOptions::get_per_env_options() {
return per_env.get();
18}

20namespace options_parser {

22template <typename Options>
23void OptionsParser<Options>::AddOption(const char* name,
                                     const char* help_text,
                                     bool Options::* field,
                                     OptionEnvvarSettings env_setting,
                                     bool default_is_true) {
options_.emplace(name,
                 OptionInfo{kBoolean,
                            std::make_shared<SimpleOptionField<bool>>(field),
                            env_setting,
                            help_text,
                            default_is_true});
34}

36template <typename Options>
37void OptionsParser<Options>::AddOption(const char* name,
                                     const char* help_text,
                                     uint64_t Options::* field,
                                     OptionEnvvarSettings env_setting) {
options_.emplace(
    name,
    OptionInfo{kUInteger,
               std::make_shared<SimpleOptionField<uint64_t>>(field),
               env_setting,
               help_text});
47}

49template <typename Options>
50void OptionsParser<Options>::AddOption(const char* name,
                                     const char* help_text,
                                     int64_t Options::* field,
                                     OptionEnvvarSettings env_setting) {
options_.emplace(
    name,
    OptionInfo{kInteger,
               std::make_shared<SimpleOptionField<int64_t>>(field),
               env_setting,
               help_text});
60}

62template <typename Options>
63void OptionsParser<Options>::AddOption(const char* name,
                                     const char* help_text,
                                     std::string Options::* field,
                                     OptionEnvvarSettings env_setting) {
options_.emplace(
    name,
    OptionInfo{kString,
               std::make_shared<SimpleOptionField<std::string>>(field),
               env_setting,
               help_text});
73}

75template <typename Options>
76void OptionsParser<Options>::AddOption(
  const char* name,
  const char* help_text,
  std::vector<std::string> Options::* field,
  OptionEnvvarSettings env_setting) {
options_.emplace(name, OptionInfo {
  kStringList,
  std::make_shared<SimpleOptionField<std::vector<std::string>>>(field),
  env_setting,
  help_text
});
87}

89template <typename Options>
90void OptionsParser<Options>::AddOption(const char* name,
                                     const char* help_text,
                                     HostPort Options::* field,
                                     OptionEnvvarSettings env_setting) {
options_.emplace(
    name,
    OptionInfo{kHostPort,
               std::make_shared<SimpleOptionField<HostPort>>(field),
               env_setting,
               help_text});
100}

102template <typename Options>
103void OptionsParser<Options>::AddOption(const char* name,
                                     const char* help_text,
                                     NoOp no_op_tag,
                                     OptionEnvvarSettings env_setting) {
options_.emplace(name, OptionInfo{kNoOp, nullptr, env_setting, help_text});
108}

110template <typename Options>
111void OptionsParser<Options>::AddOption(const char* name,
                                     const char* help_text,
                                     V8Option v8_option_tag,
                                     OptionEnvvarSettings env_setting) {
options_.emplace(name,
                 OptionInfo{kV8Option, nullptr, env_setting, help_text});
117}

119template <typename Options>
120void OptionsParser<Options>::AddAlias(const char* from,
                                    const char* to) {
aliases_[from] = { to };
123}

125template <typename Options>
126void OptionsParser<Options>::AddAlias(const char* from,
                                    const std::vector<std::string>& to) {
aliases_[from] = to;
129}

131template <typename Options>
132void OptionsParser<Options>::AddAlias(
  const char* from,
  const std::initializer_list<std::string>& to) {
AddAlias(from, std::vector<std::string>(to));
136}

138template <typename Options>
139void OptionsParser<Options>::Implies(const char* from,
                                   const char* to) {
auto it = options_.find(to);
CHECK_NE(it, options_.end())do { if (__builtin_expect(!!(!((it) != (options_.end()))), 0)
) { do { static const node::AssertionInfo args = { "../src/node_options-inl.h"
 ":" "142", "(it) != (options_.end())", __PRETTY_FUNCTION__ }
; node::Assert(args); } while (0); } } while (0);
CHECK(it->second.type == kBoolean || it->second.type == kV8Option)do { if (__builtin_expect(!!(!(it->second.type == kBoolean
 || it->second.type == kV8Option)), 0)) { do { static const
 node::AssertionInfo args = { "../src/node_options-inl.h" ":"
 "143", "it->second.type == kBoolean || it->second.type == kV8Option"
, __PRETTY_FUNCTION__ }; node::Assert(args); } while (0); } }
 while (0);
implications_.emplace(
    from, Implication{it->second.type, to, it->second.field, true});
146}

148template <typename Options>
149void OptionsParser<Options>::ImpliesNot(const char* from,
                                      const char* to) {
auto it = options_.find(to);
CHECK_NE(it, options_.end())do { if (__builtin_expect(!!(!((it) != (options_.end()))), 0)
) { do { static const node::AssertionInfo args = { "../src/node_options-inl.h"
 ":" "152", "(it) != (options_.end())", __PRETTY_FUNCTION__ }
; node::Assert(args); } while (0); } } while (0);
CHECK_EQ(it->second.type, kBoolean)do { if (__builtin_expect(!!(!((it->second.type) == (kBoolean
))), 0)) { do { static const node::AssertionInfo args = { "../src/node_options-inl.h"
 ":" "153", "(it->second.type) == (kBoolean)", __PRETTY_FUNCTION__
 }; node::Assert(args); } while (0); } } while (0);
implications_.emplace(
    from, Implication{it->second.type, to, it->second.field, false});
156}

158template <typename Options>
159template <typename OriginalField, typename ChildOptions>
160auto OptionsParser<Options>::Convert(
  std::shared_ptr<OriginalField> original,
  ChildOptions* (Options::* get_child)()) {
// If we have a field on ChildOptions, and we want to access it from an
// Options instance, we call get_child() on the original Options and then
// access it, i.e. this class implements a kind of function chaining.
struct AdaptedField : BaseOptionField {
  void* LookupImpl(Options* options) const override {
    return original->LookupImpl((options->*get_child)());
  }

  AdaptedField(
      std::shared_ptr<OriginalField> original,
      ChildOptions* (Options::* get_child)())
        : original(original), get_child(get_child) {}

  std::shared_ptr<OriginalField> original;
  ChildOptions* (Options::* get_child)();
};

return std::shared_ptr<BaseOptionField>(
4
←
Calling constructor for 'shared_ptr<node::options_parser::OptionsParser<node::PerIsolateOptions>::BaseOptionField>'→
14
←
Returning from constructor for 'shared_ptr<node::options_parser::OptionsParser<node::PerIsolateOptions>::BaseOptionField>'→
    new AdaptedField(original, get_child));
182}
183template <typename Options>
184template <typename ChildOptions>
185auto OptionsParser<Options>::Convert(
  typename OptionsParser<ChildOptions>::OptionInfo original,
  ChildOptions* (Options::* get_child)()) {
return OptionInfo{original.type,
                  Convert(original.field, get_child),
3
←
Calling 'OptionsParser::Convert'→
15
←
Returned allocated memory→
                  original.env_setting,
                  original.help_text,
                  original.default_is_true};
193}
16
←
Potential leak of memory pointed to by field '_M_pi'

195template <typename Options>
196template <typename ChildOptions>
197auto OptionsParser<Options>::Convert(
  typename OptionsParser<ChildOptions>::Implication original,
  ChildOptions* (Options::* get_child)()) {
return Implication{
    original.type,
    original.name,
    Convert(original.target_field, get_child),
    original.target_value,
};
206}

208template <typename Options>
209template <typename ChildOptions>
210void OptionsParser<Options>::Insert(
  const OptionsParser<ChildOptions>& child_options_parser,
  ChildOptions* (Options::* get_child)()) {
aliases_.insert(std::begin(child_options_parser.aliases_),
                std::end(child_options_parser.aliases_));

for (const auto& pair : child_options_parser.options_)
  options_.emplace(pair.first, Convert(pair.second, get_child));
2
←
Calling 'OptionsParser::Convert'→

for (const auto& pair : child_options_parser.implications_)
  implications_.emplace(pair.first, Convert(pair.second, get_child));
221}

223inline std::string NotAllowedInEnvErr(const std::string& arg) {
return arg + " is not allowed in NODE_OPTIONS";
225}

227inline std::string RequiresArgumentErr(const std::string& arg) {
return arg + " requires an argument";
229}

231inline std::string NegationImpliesBooleanError(const std::string& arg) {
return arg + " is an invalid negation because it is not a boolean option";
233}

235// We store some of the basic information around a single Parse call inside
236// this struct, to separate storage of command line arguments and their
237// handling. In particular, this makes it easier to introduce 'synthetic'
238// arguments that get inserted by expanding option aliases.
239struct ArgsInfo {
// Generally, the idea here is that the first entry in `*underlying` stores
// the "0th" argument (the program name), then `synthetic_args` are inserted,
// followed by the remainder of `*underlying`.
std::vector<std::string>* underlying;
std::vector<std::string> synthetic_args;

std::vector<std::string>* exec_args;

ArgsInfo(std::vector<std::string>* args,
         std::vector<std::string>* exec_args)
  : underlying(args), exec_args(exec_args) {}

size_t remaining() const {
  // -1 to account for the program name.
  return underlying->size() - 1 + synthetic_args.size();
}

bool empty() const { return remaining() == 0; }
const std::string& program_name() const { return underlying->at(0); }

std::string& first() {
  return synthetic_args.empty() ? underlying->at(1) : synthetic_args.front();
}

std::string pop_first() {
  std::string ret = std::move(first());
  if (synthetic_args.empty()) {
    // Only push arguments to `exec_args` that were also originally passed
    // on the command line (i.e. not generated through alias expansion).
    // '--' is a special case here since its purpose is to end `exec_argv`,
    // which is why we do not include it.
    if (exec_args != nullptr && ret != "--")
      exec_args->push_back(ret);
    underlying->erase(underlying->begin() + 1);
  } else {
    synthetic_args.erase(synthetic_args.begin());
  }
  return ret;
}
279};

281template <typename Options>
282void OptionsParser<Options>::Parse(
  std::vector<std::string>* const orig_args,
  std::vector<std::string>* const exec_args,
  std::vector<std::string>* const v8_args,
  Options* const options,
  OptionEnvvarSettings required_env_settings,
  std::vector<std::string>* const errors) const {
ArgsInfo args(orig_args, exec_args);

// The first entry is the process name. Make sure it ends up in the V8 argv,
// since V8::SetFlagsFromCommandLine() expects that to hold true for that
// array as well.
if (v8_args->empty())
  v8_args->push_back(args.program_name());

while (!args.empty() && errors->empty()) {
  if (args.first().size() <= 1 || args.first()[0] != '-') break;

  // We know that we're either going to consume this
  // argument or fail completely.
  const std::string arg = args.pop_first();

  if (arg == "--") {
    if (required_env_settings == kAllowedInEnvironment)
      errors->push_back(NotAllowedInEnvErr("--"));
    break;
  }

  // Only allow --foo=bar notation for options starting with double dashes.
  // (E.g. -e=a is not allowed as shorthand for --eval=a, which would
  // otherwise be the result of alias expansion.)
  const std::string::size_type equals_index =
      arg[0] == '-' && arg[1] == '-' ? arg.find('=') : std::string::npos;
  std::string name =
    equals_index == std::string::npos ? arg : arg.substr(0, equals_index);

  // Store the 'original name' of the argument. This name differs from
  // 'name' in that it contains a possible '=' sign and is not affected
  // by alias expansion.
  std::string original_name = name;
  if (equals_index != std::string::npos)
    original_name += '=';

  auto missing_argument = [&]() {
    errors->push_back(RequiresArgumentErr(original_name));
  };

  // Normalize by replacing `_` with `-` in options.
  for (std::string::size_type i = 2; i < name.size(); ++i) {
    if (name[i] == '_')
      name[i] = '-';
  }

  // Convert --no-foo to --foo and keep in mind that we're negating.
  bool is_negation = false;
  if (name.find("--no-") == 0) {
    name.erase(2, 3);  // remove no-
    is_negation = true;
  }

  {
    auto it = aliases_.end();
    // Expand aliases:
    // - If `name` can be found in `aliases_`.
    // - If `name` + '=' can be found in `aliases_`.
    // - If `name` + " <arg>" can be found in `aliases_`, and we have
    //   a subsequent argument that does not start with '-' itself.
    while ((it = aliases_.find(name)) != aliases_.end() ||
           (equals_index != std::string::npos &&
            (it = aliases_.find(name + '=')) != aliases_.end()) ||
           (!args.empty() &&
               !args.first().empty() &&
               args.first()[0] != '-' &&
            (it = aliases_.find(name + " <arg>")) != aliases_.end())) {
      const std::string prev_name = std::move(name);
      const std::vector<std::string>& expansion = it->second;

      // Use the first entry in the expansion as the new 'name'.
      name = expansion.front();

      if (expansion.size() > 1) {
        // The other arguments, if any, are going to be handled later.
        args.synthetic_args.insert(
            args.synthetic_args.begin(),
            expansion.begin() + 1,
            expansion.end());
      }

      if (name == prev_name) break;
    }
  }

  auto it = options_.find(name);

  if ((it == options_.end() ||
       it->second.env_setting == kDisallowedInEnvironment) &&
      required_env_settings == kAllowedInEnvironment) {
    errors->push_back(NotAllowedInEnvErr(original_name));
    break;
  }

  {
    std::string implied_name = name;
    if (is_negation) {
      // Implications for negated options are defined with "--no-".
      implied_name.insert(2, "no-");
    }
    auto implications = implications_.equal_range(implied_name);
    for (auto it = implications.first; it != implications.second; ++it) {
      if (it->second.type == kV8Option) {
        v8_args->push_back(it->second.name);
      } else {
        *it->second.target_field->template Lookup<bool>(options) =
            it->second.target_value;
      }
    }
  }

  if (it == options_.end()) {
    v8_args->push_back(arg);
    continue;
  }

  const OptionInfo& info = it->second;

  // Some V8 options can be negated and they are validated by V8 later.
  if (is_negation && info.type != kBoolean && info.type != kV8Option) {
    errors->push_back(NegationImpliesBooleanError(arg));
    break;
  }

  std::string value;
  if (info.type != kBoolean && info.type != kNoOp && info.type != kV8Option) {
    if (equals_index != std::string::npos) {
      value = arg.substr(equals_index + 1);
      if (value.empty()) {
        missing_argument();
        break;
      }
    } else {
      if (args.empty()) {
        missing_argument();
        break;
      }

      value = args.pop_first();

      if (!value.empty() && value[0] == '-') {
        missing_argument();
        break;
      } else {
        if (!value.empty() && value[0] == '\\' && value[1] == '-')
          value = value.substr(1);  // Treat \- as escaping an -.
      }
    }
  }

  switch (info.type) {
    case kBoolean:
      *Lookup<bool>(info.field, options) = !is_negation;
      break;
    case kInteger:
      *Lookup<int64_t>(info.field, options) = std::atoll(value.c_str());
      break;
    case kUInteger:
      *Lookup<uint64_t>(info.field, options) = std::stoull(value);
      break;
    case kString:
      *Lookup<std::string>(info.field, options) = value;
      break;
    case kStringList:
      Lookup<std::vector<std::string>>(info.field, options)
          ->emplace_back(std::move(value));
      break;
    case kHostPort:
      Lookup<HostPort>(info.field, options)
          ->Update(SplitHostPort(value, errors));
      break;
    case kNoOp:
      break;
    case kV8Option:
      v8_args->push_back(arg);
      break;
    default:
      UNREACHABLE()do { static const node::AssertionInfo args = { "../src/node_options-inl.h"
 ":" "466", "\"Unreachable code reached\"", __PRETTY_FUNCTION__
 }; node::Assert(args); } while (0);
  }
}
options->CheckOptions(errors);
470}

472}  // namespace options_parser
473}  // namespace node

475#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

477#endif  // SRC_NODE_OPTIONS_INL_H_

←

/usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/bits/shared_ptr.h

→

1// shared_ptr and weak_ptr implementation -*- C++ -*-

3// Copyright (C) 2007-2018 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library.  This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.

11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14// GNU General Public License for more details.

16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.

20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23// <http://www.gnu.org/licenses/>.

25// GCC Note: Based on files from version 1.32.0 of the Boost library.

27//  shared_count.hpp
28//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.

30//  shared_ptr.hpp
31//  Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes.
32//  Copyright (C) 2001, 2002, 2003 Peter Dimov

34//  weak_ptr.hpp
35//  Copyright (C) 2001, 2002, 2003 Peter Dimov

37//  enable_shared_from_this.hpp
38//  Copyright (C) 2002 Peter Dimov

40// Distributed under the Boost Software License, Version 1.0. (See
41// accompanying file LICENSE_1_0.txt or copy at
42// http://www.boost.org/LICENSE_1_0.txt)

44/** @file
*  This is an internal header file, included by other library headers.
*  Do not attempt to use it directly. @headername{memory}
*/

49#ifndef _SHARED_PTR_H1
50#define _SHARED_PTR_H1 1

52#include <bits/shared_ptr_base.h>

54namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
55{
56_GLIBCXX_BEGIN_NAMESPACE_VERSION

/**
 * @addtogroup pointer_abstractions
 * @{
 */

/// 20.7.2.2.11 shared_ptr I/O
template<typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp>
  inline std::basic_ostream<_Ch, _Tr>&
  operator<<(std::basic_ostream<_Ch, _Tr>& __os,
      const __shared_ptr<_Tp, _Lp>& __p)
  {
    __os << __p.get();
    return __os;
  }

template<typename _Del, typename _Tp, _Lock_policy _Lp>
  inline _Del*
  get_deleter(const __shared_ptr<_Tp, _Lp>& __p) noexcept
  {
77#if __cpp_rtti
    return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del)));
79#else
    return 0;
81#endif
  }

/// 20.7.2.2.10 shared_ptr get_deleter
template<typename _Del, typename _Tp>
  inline _Del*
  get_deleter(const shared_ptr<_Tp>& __p) noexcept
  {
89#if __cpp_rtti
    return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del)));
91#else
    return 0;
93#endif
  }

/**
 *  @brief  A smart pointer with reference-counted copy semantics.
 *
 *  The object pointed to is deleted when the last shared_ptr pointing to
 *  it is destroyed or reset.
*/
template<typename _Tp>
  class shared_ptr : public __shared_ptr<_Tp>
  {
    template<typename... _Args>
using _Constructible = typename enable_if<
 is_constructible<__shared_ptr<_Tp>, _Args...>::value
>::type;

    template<typename _Arg>
using _Assignable = typename enable_if<
 is_assignable<__shared_ptr<_Tp>&, _Arg>::value, shared_ptr&
>::type;

  public:

    using element_type = typename __shared_ptr<_Tp>::element_type;

119#if __cplusplus201703L > 201402L
120# define __cpp_lib_shared_ptr_weak_type201606 201606
    using weak_type = weak_ptr<_Tp>;
122#endif
    /**
     *  @brief  Construct an empty %shared_ptr.
     *  @post   use_count()==0 && get()==0
     */
    constexpr shared_ptr() noexcept : __shared_ptr<_Tp>() { }

    shared_ptr(const shared_ptr&) noexcept = default;

    /**
     *  @brief  Construct a %shared_ptr that owns the pointer @a __p.
     *  @param  __p  A pointer that is convertible to element_type*.
     *  @post   use_count() == 1 && get() == __p
     *  @throw  std::bad_alloc, in which case @c delete @a __p is called.
     */
    template<typename _Yp, typename = _Constructible<_Yp*>>
explicit
shared_ptr(_Yp* __p) : __shared_ptr<_Tp>(__p) { }
5
←
Calling constructor for '__shared_ptr<node::options_parser::OptionsParser<node::PerIsolateOptions>::BaseOptionField, __gnu_cxx::_S_atomic>'→
13
←
Returning from constructor for '__shared_ptr<node::options_parser::OptionsParser<node::PerIsolateOptions>::BaseOptionField, __gnu_cxx::_S_atomic>'→

    /**
     *  @brief  Construct a %shared_ptr that owns the pointer @a __p
     *          and the deleter @a __d.
     *  @param  __p  A pointer.
     *  @param  __d  A deleter.
     *  @post   use_count() == 1 && get() == __p
     *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
     *
     *  Requirements: _Deleter's copy constructor and destructor must
     *  not throw
     *
     *  __shared_ptr will release __p by calling __d(__p)
     */
    template<typename _Yp, typename _Deleter,
      typename = _Constructible<_Yp*, _Deleter>>
shared_ptr(_Yp* __p, _Deleter __d)
      : __shared_ptr<_Tp>(__p, std::move(__d)) { }

    /**
     *  @brief  Construct a %shared_ptr that owns a null pointer
     *          and the deleter @a __d.
     *  @param  __p  A null pointer constant.
     *  @param  __d  A deleter.
     *  @post   use_count() == 1 && get() == __p
     *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
     *
     *  Requirements: _Deleter's copy constructor and destructor must
     *  not throw
     *
     *  The last owner will call __d(__p)
     */
    template<typename _Deleter>
shared_ptr(nullptr_t __p, _Deleter __d)
      : __shared_ptr<_Tp>(__p, std::move(__d)) { }

    /**
     *  @brief  Construct a %shared_ptr that owns the pointer @a __p
     *          and the deleter @a __d.
     *  @param  __p  A pointer.
     *  @param  __d  A deleter.
     *  @param  __a  An allocator.
     *  @post   use_count() == 1 && get() == __p
     *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
     *
     *  Requirements: _Deleter's copy constructor and destructor must
     *  not throw _Alloc's copy constructor and destructor must not
     *  throw.
     *
     *  __shared_ptr will release __p by calling __d(__p)
     */
    template<typename _Yp, typename _Deleter, typename _Alloc,
      typename = _Constructible<_Yp*, _Deleter, _Alloc>>
shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a)
: __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { }

    /**
     *  @brief  Construct a %shared_ptr that owns a null pointer
     *          and the deleter @a __d.
     *  @param  __p  A null pointer constant.
     *  @param  __d  A deleter.
     *  @param  __a  An allocator.
     *  @post   use_count() == 1 && get() == __p
     *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
     *
     *  Requirements: _Deleter's copy constructor and destructor must
     *  not throw _Alloc's copy constructor and destructor must not
     *  throw.
     *
     *  The last owner will call __d(__p)
     */
    template<typename _Deleter, typename _Alloc>
shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
: __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { }

    // Aliasing constructor

    /**
     *  @brief  Constructs a %shared_ptr instance that stores @a __p
     *          and shares ownership with @a __r.
     *  @param  __r  A %shared_ptr.
     *  @param  __p  A pointer that will remain valid while @a *__r is valid.
     *  @post   get() == __p && use_count() == __r.use_count()
     *
     *  This can be used to construct a @c shared_ptr to a sub-object
     *  of an object managed by an existing @c shared_ptr.
     *
     * @code
     * shared_ptr< pair<int,int> > pii(new pair<int,int>());
     * shared_ptr<int> pi(pii, &pii->first);
     * assert(pii.use_count() == 2);
     * @endcode
     */
    template<typename _Yp>
shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) noexcept
: __shared_ptr<_Tp>(__r, __p) { }

    /**
     *  @brief  If @a __r is empty, constructs an empty %shared_ptr;
     *          otherwise construct a %shared_ptr that shares ownership
     *          with @a __r.
     *  @param  __r  A %shared_ptr.
     *  @post   get() == __r.get() && use_count() == __r.use_count()
     */
    template<typename _Yp,
      typename = _Constructible<const shared_ptr<_Yp>&>>
shared_ptr(const shared_ptr<_Yp>& __r) noexcept
      : __shared_ptr<_Tp>(__r) { }

    /**
     *  @brief  Move-constructs a %shared_ptr instance from @a __r.
     *  @param  __r  A %shared_ptr rvalue.
     *  @post   *this contains the old value of @a __r, @a __r is empty.
     */
    shared_ptr(shared_ptr&& __r) noexcept
    : __shared_ptr<_Tp>(std::move(__r)) { }

    /**
     *  @brief  Move-constructs a %shared_ptr instance from @a __r.
     *  @param  __r  A %shared_ptr rvalue.
     *  @post   *this contains the old value of @a __r, @a __r is empty.
     */
    template<typename _Yp, typename = _Constructible<shared_ptr<_Yp>>>
shared_ptr(shared_ptr<_Yp>&& __r) noexcept
: __shared_ptr<_Tp>(std::move(__r)) { }

    /**
     *  @brief  Constructs a %shared_ptr that shares ownership with @a __r
     *          and stores a copy of the pointer stored in @a __r.
     *  @param  __r  A weak_ptr.
     *  @post   use_count() == __r.use_count()
     *  @throw  bad_weak_ptr when __r.expired(),
     *          in which case the constructor has no effect.
     */
    template<typename _Yp, typename = _Constructible<const weak_ptr<_Yp>&>>
explicit shared_ptr(const weak_ptr<_Yp>& __r)
: __shared_ptr<_Tp>(__r) { }

278#if _GLIBCXX_USE_DEPRECATED1
279#pragma GCC diagnostic push
280#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    template<typename _Yp, typename = _Constructible<auto_ptr<_Yp>>>
shared_ptr(auto_ptr<_Yp>&& __r);
283#pragma GCC diagnostic pop
284#endif

    // _GLIBCXX_RESOLVE_LIB_DEFECTS
    // 2399. shared_ptr's constructor from unique_ptr should be constrained
    template<typename _Yp, typename _Del,
      typename = _Constructible<unique_ptr<_Yp, _Del>>>
shared_ptr(unique_ptr<_Yp, _Del>&& __r)
: __shared_ptr<_Tp>(std::move(__r)) { }

293#if __cplusplus201703L <= 201402L && _GLIBCXX_USE_DEPRECATED1
    // This non-standard constructor exists to support conversions that
    // were possible in C++11 and C++14 but are ill-formed in C++17.
    // If an exception is thrown this constructor has no effect.
    template<typename _Yp, typename _Del,
_Constructible<unique_ptr<_Yp, _Del>, __sp_array_delete>* = 0>
shared_ptr(unique_ptr<_Yp, _Del>&& __r)
: __shared_ptr<_Tp>(std::move(__r), __sp_array_delete()) { }
301#endif

    /**
     *  @brief  Construct an empty %shared_ptr.
     *  @post   use_count() == 0 && get() == nullptr
     */
    constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { }

    shared_ptr& operator=(const shared_ptr&) noexcept = default;

    template<typename _Yp>
_Assignable<const shared_ptr<_Yp>&>
operator=(const shared_ptr<_Yp>& __r) noexcept
{
 this->__shared_ptr<_Tp>::operator=(__r);
 return *this;
}

319#if _GLIBCXX_USE_DEPRECATED1
320#pragma GCC diagnostic push
321#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    template<typename _Yp>
_Assignable<auto_ptr<_Yp>>
operator=(auto_ptr<_Yp>&& __r)
{
 this->__shared_ptr<_Tp>::operator=(std::move(__r));
 return *this;
}
329#pragma GCC diagnostic pop
330#endif

    shared_ptr&
    operator=(shared_ptr&& __r) noexcept
    {
this->__shared_ptr<_Tp>::operator=(std::move(__r));
return *this;
    }

    template<class _Yp>
_Assignable<shared_ptr<_Yp>>
operator=(shared_ptr<_Yp>&& __r) noexcept
{
 this->__shared_ptr<_Tp>::operator=(std::move(__r));
 return *this;
}

    template<typename _Yp, typename _Del>
_Assignable<unique_ptr<_Yp, _Del>>
operator=(unique_ptr<_Yp, _Del>&& __r)
{
 this->__shared_ptr<_Tp>::operator=(std::move(__r));
 return *this;
}

  private:
    // This constructor is non-standard, it is used by allocate_shared.
    template<typename _Alloc, typename... _Args>
shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args)
: __shared_ptr<_Tp>(__tag, std::forward<_Args>(__args)...)
{ }

    template<typename _Yp, typename _Alloc, typename... _Args>
friend shared_ptr<_Yp>
allocate_shared(const _Alloc& __a, _Args&&... __args);

    // This constructor is non-standard, it is used by weak_ptr::lock().
    shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t)
    : __shared_ptr<_Tp>(__r, std::nothrow) { }

    friend class weak_ptr<_Tp>;
  };

373#if __cpp_deduction_guides201703L >= 201606
template<typename _Tp>
  shared_ptr(weak_ptr<_Tp>) ->  shared_ptr<_Tp>;
template<typename _Tp, typename _Del>
  shared_ptr(unique_ptr<_Tp, _Del>) ->  shared_ptr<_Tp>;
378#endif

// 20.7.2.2.7 shared_ptr comparisons
template<typename _Tp, typename _Up>
  inline bool
  operator==(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  { return __a.get() == __b.get(); }

template<typename _Tp>
  inline bool
  operator==(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
  { return !__a; }

template<typename _Tp>
  inline bool
  operator==(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
  { return !__a; }

template<typename _Tp, typename _Up>
  inline bool
  operator!=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  { return __a.get() != __b.get(); }

template<typename _Tp>
  inline bool
  operator!=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
  { return (bool)__a; }

template<typename _Tp>
  inline bool
  operator!=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
  { return (bool)__a; }

template<typename _Tp, typename _Up>
  inline bool
  operator<(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  {
    using _Tp_elt = typename shared_ptr<_Tp>::element_type;
    using _Up_elt = typename shared_ptr<_Up>::element_type;
    using _Vp = typename common_type<_Tp_elt*, _Up_elt*>::type;
    return less<_Vp>()(__a.get(), __b.get());
  }

template<typename _Tp>
  inline bool
  operator<(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
  {
    using _Tp_elt = typename shared_ptr<_Tp>::element_type;
    return less<_Tp_elt*>()(__a.get(), nullptr);
  }

template<typename _Tp>
  inline bool
  operator<(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
  {
    using _Tp_elt = typename shared_ptr<_Tp>::element_type;
    return less<_Tp_elt*>()(nullptr, __a.get());
  }

template<typename _Tp, typename _Up>
  inline bool
  operator<=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  { return !(__b < __a); }

template<typename _Tp>
  inline bool
  operator<=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
  { return !(nullptr < __a); }

template<typename _Tp>
  inline bool
  operator<=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
  { return !(__a < nullptr); }

template<typename _Tp, typename _Up>
  inline bool
  operator>(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  { return (__b < __a); }

template<typename _Tp>
  inline bool
  operator>(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
  { return nullptr < __a; }

template<typename _Tp>
  inline bool
  operator>(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
  { return __a < nullptr; }

template<typename _Tp, typename _Up>
  inline bool
  operator>=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  { return !(__a < __b); }

template<typename _Tp>
  inline bool
  operator>=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
  { return !(__a < nullptr); }

template<typename _Tp>
  inline bool
  operator>=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
  { return !(nullptr < __a); }

template<typename _Tp>
  struct less<shared_ptr<_Tp>> : public _Sp_less<shared_ptr<_Tp>>
  { };

// 20.7.2.2.8 shared_ptr specialized algorithms.
template<typename _Tp>
  inline void
  swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b) noexcept
  { __a.swap(__b); }

// 20.7.2.2.9 shared_ptr casts.
template<typename _Tp, typename _Up>
  inline shared_ptr<_Tp>
  static_pointer_cast(const shared_ptr<_Up>& __r) noexcept
  {
    using _Sp = shared_ptr<_Tp>;
    return _Sp(__r, static_cast<typename _Sp::element_type*>(__r.get()));
  }

template<typename _Tp, typename _Up>
  inline shared_ptr<_Tp>
  const_pointer_cast(const shared_ptr<_Up>& __r) noexcept
  {
    using _Sp = shared_ptr<_Tp>;
    return _Sp(__r, const_cast<typename _Sp::element_type*>(__r.get()));
  }

template<typename _Tp, typename _Up>
  inline shared_ptr<_Tp>
  dynamic_pointer_cast(const shared_ptr<_Up>& __r) noexcept
  {
    using _Sp = shared_ptr<_Tp>;
    if (auto* __p = dynamic_cast<typename _Sp::element_type*>(__r.get()))
return _Sp(__r, __p);
    return _Sp();
  }

519#if __cplusplus201703L > 201402L
template<typename _Tp, typename _Up>
  inline shared_ptr<_Tp>
  reinterpret_pointer_cast(const shared_ptr<_Up>& __r) noexcept
  {
    using _Sp = shared_ptr<_Tp>;
    return _Sp(__r, reinterpret_cast<typename _Sp::element_type*>(__r.get()));
  }
527#endif

/**
 *  @brief  A smart pointer with weak semantics.
 *
 *  With forwarding constructors and assignment operators.
 */
template<typename _Tp>
  class weak_ptr : public __weak_ptr<_Tp>
  {
    template<typename _Arg>
using _Constructible = typename enable_if<
 is_constructible<__weak_ptr<_Tp>, _Arg>::value
>::type;

    template<typename _Arg>
using _Assignable = typename enable_if<
 is_assignable<__weak_ptr<_Tp>&, _Arg>::value, weak_ptr&
>::type;

  public:
    constexpr weak_ptr() noexcept = default;

    template<typename _Yp,
      typename = _Constructible<const shared_ptr<_Yp>&>>
weak_ptr(const shared_ptr<_Yp>& __r) noexcept
: __weak_ptr<_Tp>(__r) { }

    weak_ptr(const weak_ptr&) noexcept = default;

    template<typename _Yp, typename = _Constructible<const weak_ptr<_Yp>&>>
weak_ptr(const weak_ptr<_Yp>& __r) noexcept
: __weak_ptr<_Tp>(__r) { }

    weak_ptr(weak_ptr&&) noexcept = default;

    template<typename _Yp, typename = _Constructible<weak_ptr<_Yp>>>
weak_ptr(weak_ptr<_Yp>&& __r) noexcept
: __weak_ptr<_Tp>(std::move(__r)) { }

    weak_ptr&
    operator=(const weak_ptr& __r) noexcept = default;

    template<typename _Yp>
_Assignable<const weak_ptr<_Yp>&>
operator=(const weak_ptr<_Yp>& __r) noexcept
{
 this->__weak_ptr<_Tp>::operator=(__r);
 return *this;
}

    template<typename _Yp>
_Assignable<const shared_ptr<_Yp>&>
operator=(const shared_ptr<_Yp>& __r) noexcept
{
 this->__weak_ptr<_Tp>::operator=(__r);
 return *this;
}

    weak_ptr&
    operator=(weak_ptr&& __r) noexcept = default;

    template<typename _Yp>
_Assignable<weak_ptr<_Yp>>
operator=(weak_ptr<_Yp>&& __r) noexcept
{
 this->__weak_ptr<_Tp>::operator=(std::move(__r));
 return *this;
}

    shared_ptr<_Tp>
    lock() const noexcept
    { return shared_ptr<_Tp>(*this, std::nothrow); }
  };

602#if __cpp_deduction_guides201703L >= 201606
template<typename _Tp>
  weak_ptr(shared_ptr<_Tp>) ->  weak_ptr<_Tp>;
605#endif

// 20.7.2.3.6 weak_ptr specialized algorithms.
template<typename _Tp>
  inline void
  swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b) noexcept
  { __a.swap(__b); }


/// Primary template owner_less
template<typename _Tp = void>
  struct owner_less;

/// Void specialization of owner_less
template<>
  struct owner_less<void> : _Sp_owner_less<void, void>
  { };

/// Partial specialization of owner_less for shared_ptr.
template<typename _Tp>
  struct owner_less<shared_ptr<_Tp>>
  : public _Sp_owner_less<shared_ptr<_Tp>, weak_ptr<_Tp>>
  { };

/// Partial specialization of owner_less for weak_ptr.
template<typename _Tp>
  struct owner_less<weak_ptr<_Tp>>
  : public _Sp_owner_less<weak_ptr<_Tp>, shared_ptr<_Tp>>
  { };

/**
 *  @brief Base class allowing use of member function shared_from_this.
 */
template<typename _Tp>
  class enable_shared_from_this
  {
  protected:
    constexpr enable_shared_from_this() noexcept { }

    enable_shared_from_this(const enable_shared_from_this&) noexcept { }

    enable_shared_from_this&
    operator=(const enable_shared_from_this&) noexcept
    { return *this; }

    ~enable_shared_from_this() { }

  public:
    shared_ptr<_Tp>
    shared_from_this()
    { return shared_ptr<_Tp>(this->_M_weak_this); }

    shared_ptr<const _Tp>
    shared_from_this() const
    { return shared_ptr<const _Tp>(this->_M_weak_this); }

661#if __cplusplus201703L > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
662#define __cpp_lib_enable_shared_from_this201603 201603
    weak_ptr<_Tp>
    weak_from_this() noexcept
    { return this->_M_weak_this; }

    weak_ptr<const _Tp>
    weak_from_this() const noexcept
    { return this->_M_weak_this; }
670#endif

  private:
    template<typename _Tp1>
void
_M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const noexcept
{ _M_weak_this._M_assign(__p, __n); }

    // Found by ADL when this is an associated class.
    friend const enable_shared_from_this*
    __enable_shared_from_this_base(const __shared_count<>&,
		     const enable_shared_from_this* __p)
    { return __p; }

    template<typename, _Lock_policy>
friend class __shared_ptr;

    mutable weak_ptr<_Tp>  _M_weak_this;
  };

/**
 *  @brief  Create an object that is owned by a shared_ptr.
 *  @param  __a     An allocator.
 *  @param  __args  Arguments for the @a _Tp object's constructor.
 *  @return A shared_ptr that owns the newly created object.
 *  @throw  An exception thrown from @a _Alloc::allocate or from the
 *          constructor of @a _Tp.
 *
 *  A copy of @a __a will be used to allocate memory for the shared_ptr
 *  and the new object.
 */
template<typename _Tp, typename _Alloc, typename... _Args>
  inline shared_ptr<_Tp>
  allocate_shared(const _Alloc& __a, _Args&&... __args)
  {
    return shared_ptr<_Tp>(_Sp_alloc_shared_tag<_Alloc>{__a},
	     std::forward<_Args>(__args)...);
  }

/**
 *  @brief  Create an object that is owned by a shared_ptr.
 *  @param  __args  Arguments for the @a _Tp object's constructor.
 *  @return A shared_ptr that owns the newly created object.
 *  @throw  std::bad_alloc, or an exception thrown from the
 *          constructor of @a _Tp.
 */
template<typename _Tp, typename... _Args>
  inline shared_ptr<_Tp>
  make_shared(_Args&&... __args)
  {
    typedef typename std::remove_cv<_Tp>::type _Tp_nc;
    return std::allocate_shared<_Tp>(std::allocator<_Tp_nc>(),
		       std::forward<_Args>(__args)...);
  }

/// std::hash specialization for shared_ptr.
template<typename _Tp>
  struct hash<shared_ptr<_Tp>>
  : public __hash_base<size_t, shared_ptr<_Tp>>
  {
    size_t
    operator()(const shared_ptr<_Tp>& __s) const noexcept
    {
return std::hash<typename shared_ptr<_Tp>::element_type*>()(__s.get());
    }
  };

// @} group pointer_abstractions

739_GLIBCXX_END_NAMESPACE_VERSION
740} // namespace

742#endif // _SHARED_PTR_H

←

/usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/bits/shared_ptr_base.h

1// shared_ptr and weak_ptr implementation details -*- C++ -*-

3// Copyright (C) 2007-2018 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library.  This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.

11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14// GNU General Public License for more details.

16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.

20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23// <http://www.gnu.org/licenses/>.

25// GCC Note: Based on files from version 1.32.0 of the Boost library.

27//  shared_count.hpp
28//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.

30//  shared_ptr.hpp
31//  Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes.
32//  Copyright (C) 2001, 2002, 2003 Peter Dimov

34//  weak_ptr.hpp
35//  Copyright (C) 2001, 2002, 2003 Peter Dimov

37//  enable_shared_from_this.hpp
38//  Copyright (C) 2002 Peter Dimov

40// Distributed under the Boost Software License, Version 1.0. (See
41// accompanying file LICENSE_1_0.txt or copy at
42// http://www.boost.org/LICENSE_1_0.txt)

44/** @file bits/shared_ptr_base.h
*  This is an internal header file, included by other library headers.
*  Do not attempt to use it directly. @headername{memory}
*/

49#ifndef _SHARED_PTR_BASE_H1
50#define _SHARED_PTR_BASE_H1 1

52#include <typeinfo>
53#include <bits/allocated_ptr.h>
54#include <bits/refwrap.h>
55#include <bits/stl_function.h>
56#include <ext/aligned_buffer.h>

58namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
59{
60_GLIBCXX_BEGIN_NAMESPACE_VERSION

62#if _GLIBCXX_USE_DEPRECATED1
63#pragma GCC diagnostic push
64#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
template<typename> class auto_ptr;
66#pragma GCC diagnostic pop
67#endif

/**
 *  @brief  Exception possibly thrown by @c shared_ptr.
 *  @ingroup exceptions
 */
class bad_weak_ptr : public std::exception
{
public:
  virtual char const* what() const noexcept;

  virtual ~bad_weak_ptr() noexcept;
};

// Substitute for bad_weak_ptr object in the case of -fno-exceptions.
inline void
__throw_bad_weak_ptr()
{ _GLIBCXX_THROW_OR_ABORT(bad_weak_ptr())(__builtin_abort()); }

using __gnu_cxx::_Lock_policy;
using __gnu_cxx::__default_lock_policy;
using __gnu_cxx::_S_single;
using __gnu_cxx::_S_mutex;
using __gnu_cxx::_S_atomic;

// Empty helper class except when the template argument is _S_mutex.
template<_Lock_policy _Lp>
  class _Mutex_base
  {
  protected:
    // The atomic policy uses fully-fenced builtins, single doesn't care.
    enum { _S_need_barriers = 0 };
  };

template<>
  class _Mutex_base<_S_mutex>
  : public __gnu_cxx::__mutex
  {
  protected:
    // This policy is used when atomic builtins are not available.
    // The replacement atomic operations might not have the necessary
    // memory barriers.
    enum { _S_need_barriers = 1 };
  };

template<_Lock_policy _Lp = __default_lock_policy>
  class _Sp_counted_base
  : public _Mutex_base<_Lp>
  {
  public:
    _Sp_counted_base() noexcept
    : _M_use_count(1), _M_weak_count(1) { }

    virtual
    ~_Sp_counted_base() noexcept
    { }

    // Called when _M_use_count drops to zero, to release the resources
    // managed by *this.
    virtual void
    _M_dispose() noexcept = 0;

    // Called when _M_weak_count drops to zero.
    virtual void
    _M_destroy() noexcept
    { delete this; }

    virtual void*
    _M_get_deleter(const std::type_info&) noexcept = 0;

    void
    _M_add_ref_copy()
    { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); }

    void
    _M_add_ref_lock();

    bool
    _M_add_ref_lock_nothrow();

    void
    _M_release() noexcept
    {
      // Be race-detector-friendly.  For more info see bits/c++config.
      _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_use_count);
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
 {
          _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_use_count);
   _M_dispose();
   // There must be a memory barrier between dispose() and destroy()
   // to ensure that the effects of dispose() are observed in the
   // thread that runs destroy().
   // See http://gcc.gnu.org/ml/libstdc++/2005-11/msg00136.html
   if (_Mutex_base<_Lp>::_S_need_barriers)
     {
__atomic_thread_fence (__ATOMIC_ACQ_REL4);
     }

          // Be race-detector-friendly.  For more info see bits/c++config.
          _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
   if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count,
				       -1) == 1)
            {
              _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
       _M_destroy();
            }
 }
    }

    void
    _M_weak_add_ref() noexcept
    { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); }

    void
    _M_weak_release() noexcept
    {
      // Be race-detector-friendly. For more info see bits/c++config.
      _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1)
 {
          _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
   if (_Mutex_base<_Lp>::_S_need_barriers)
     {
       // See _M_release(),
       // destroy() must observe results of dispose()
__atomic_thread_fence (__ATOMIC_ACQ_REL4);
     }
   _M_destroy();
 }
    }

    long
    _M_get_use_count() const noexcept
    {
      // No memory barrier is used here so there is no synchronization
      // with other threads.
      return __atomic_load_n(&_M_use_count, __ATOMIC_RELAXED0);
    }

  private:
    _Sp_counted_base(_Sp_counted_base const&) = delete;
    _Sp_counted_base& operator=(_Sp_counted_base const&) = delete;

    _Atomic_word  _M_use_count;     // #shared
    _Atomic_word  _M_weak_count;    // #weak + (#shared != 0)
  };

template<>
  inline void
  _Sp_counted_base<_S_single>::
  _M_add_ref_lock()
  {
    if (_M_use_count == 0)
__throw_bad_weak_ptr();
    ++_M_use_count;
  }

template<>
  inline void
  _Sp_counted_base<_S_mutex>::
  _M_add_ref_lock()
  {
    __gnu_cxx::__scoped_lock sentry(*this);
    if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
{
 _M_use_count = 0;
 __throw_bad_weak_ptr();
}
  }

template<>
  inline void
  _Sp_counted_base<_S_atomic>::
  _M_add_ref_lock()
  {
    // Perform lock-free add-if-not-zero operation.
    _Atomic_word __count = _M_get_use_count();
    do
{
 if (__count == 0)
   __throw_bad_weak_ptr();
 // Replace the current counter value with the old value + 1, as
 // long as it's not changed meanwhile.
}
    while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1,
			  true, __ATOMIC_ACQ_REL4,
			  __ATOMIC_RELAXED0));
  }

template<>
  inline bool
  _Sp_counted_base<_S_single>::
  _M_add_ref_lock_nothrow()
  {
    if (_M_use_count == 0)
return false;
    ++_M_use_count;
    return true;
  }

template<>
  inline bool
  _Sp_counted_base<_S_mutex>::
  _M_add_ref_lock_nothrow()
  {
    __gnu_cxx::__scoped_lock sentry(*this);
    if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
{
 _M_use_count = 0;
 return false;
}
    return true;
  }

template<>
  inline bool
  _Sp_counted_base<_S_atomic>::
  _M_add_ref_lock_nothrow()
  {
    // Perform lock-free add-if-not-zero operation.
    _Atomic_word __count = _M_get_use_count();
    do
{
 if (__count == 0)
   return false;
 // Replace the current counter value with the old value + 1, as
 // long as it's not changed meanwhile.
}
    while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1,
			  true, __ATOMIC_ACQ_REL4,
			  __ATOMIC_RELAXED0));
    return true;
  }

template<>
  inline void
  _Sp_counted_base<_S_single>::_M_add_ref_copy()
  { ++_M_use_count; }

template<>
  inline void
  _Sp_counted_base<_S_single>::_M_release() noexcept
  {
    if (--_M_use_count == 0)
      {
        _M_dispose();
        if (--_M_weak_count == 0)
          _M_destroy();
      }
  }

template<>
  inline void
  _Sp_counted_base<_S_single>::_M_weak_add_ref() noexcept
  { ++_M_weak_count; }

template<>
  inline void
  _Sp_counted_base<_S_single>::_M_weak_release() noexcept
  {
    if (--_M_weak_count == 0)
      _M_destroy();
  }

template<>
  inline long
  _Sp_counted_base<_S_single>::_M_get_use_count() const noexcept
  { return _M_use_count; }


// Forward declarations.
template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
  class __shared_ptr;

template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
  class __weak_ptr;

template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
  class __enable_shared_from_this;

template<typename _Tp>
  class shared_ptr;

template<typename _Tp>
  class weak_ptr;

template<typename _Tp>
  struct owner_less;

template<typename _Tp>
  class enable_shared_from_this;

template<_Lock_policy _Lp = __default_lock_policy>
  class __weak_count;

template<_Lock_policy _Lp = __default_lock_policy>
  class __shared_count;


// Counted ptr with no deleter or allocator support
template<typename _Ptr, _Lock_policy _Lp>
  class _Sp_counted_ptr final : public _Sp_counted_base<_Lp>
  {
  public:
    explicit
    _Sp_counted_ptr(_Ptr __p) noexcept
    : _M_ptr(__p) { }

    virtual void
    _M_dispose() noexcept
    { delete _M_ptr; }

    virtual void
    _M_destroy() noexcept
    { delete this; }

    virtual void*
    _M_get_deleter(const std::type_info&) noexcept
    { return nullptr; }

    _Sp_counted_ptr(const _Sp_counted_ptr&) = delete;
    _Sp_counted_ptr& operator=(const _Sp_counted_ptr&) = delete;

  private:
    _Ptr             _M_ptr;
  };

template<>
  inline void
  _Sp_counted_ptr<nullptr_t, _S_single>::_M_dispose() noexcept { }

template<>
  inline void
  _Sp_counted_ptr<nullptr_t, _S_mutex>::_M_dispose() noexcept { }

template<>
  inline void
  _Sp_counted_ptr<nullptr_t, _S_atomic>::_M_dispose() noexcept { }

template<int _Nm, typename _Tp,
  bool __use_ebo = !__is_final(_Tp) && __is_empty(_Tp)>
  struct _Sp_ebo_helper;

/// Specialization using EBO.
template<int _Nm, typename _Tp>
  struct _Sp_ebo_helper<_Nm, _Tp, true> : private _Tp
  {
    explicit _Sp_ebo_helper(const _Tp& __tp) : _Tp(__tp) { }
    explicit _Sp_ebo_helper(_Tp&& __tp) : _Tp(std::move(__tp)) { }

    static _Tp&
    _S_get(_Sp_ebo_helper& __eboh) { return static_cast<_Tp&>(__eboh); }
  };

/// Specialization not using EBO.
template<int _Nm, typename _Tp>
  struct _Sp_ebo_helper<_Nm, _Tp, false>
  {
    explicit _Sp_ebo_helper(const _Tp& __tp) : _M_tp(__tp) { }
    explicit _Sp_ebo_helper(_Tp&& __tp) : _M_tp(std::move(__tp)) { }

    static _Tp&
    _S_get(_Sp_ebo_helper& __eboh)
    { return __eboh._M_tp; }

  private:
    _Tp _M_tp;
  };

// Support for custom deleter and/or allocator
template<typename _Ptr, typename _Deleter, typename _Alloc, _Lock_policy _Lp>
  class _Sp_counted_deleter final : public _Sp_counted_base<_Lp>
  {
    class _Impl : _Sp_ebo_helper<0, _Deleter>, _Sp_ebo_helper<1, _Alloc>
    {
typedef _Sp_ebo_helper<0, _Deleter>	_Del_base;
typedef _Sp_ebo_helper<1, _Alloc>	_Alloc_base;

    public:
_Impl(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
: _M_ptr(__p), _Del_base(std::move(__d)), _Alloc_base(__a)
{ }

_Deleter& _M_del() noexcept { return _Del_base::_S_get(*this); }
_Alloc& _M_alloc() noexcept { return _Alloc_base::_S_get(*this); }

_Ptr _M_ptr;
    };

  public:
    using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_deleter>;

    // __d(__p) must not throw.
    _Sp_counted_deleter(_Ptr __p, _Deleter __d) noexcept
    : _M_impl(__p, std::move(__d), _Alloc()) { }

    // __d(__p) must not throw.
    _Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
    : _M_impl(__p, std::move(__d), __a) { }

    ~_Sp_counted_deleter() noexcept { }

    virtual void
    _M_dispose() noexcept
    { _M_impl._M_del()(_M_impl._M_ptr); }

    virtual void
    _M_destroy() noexcept
    {
__allocator_type __a(_M_impl._M_alloc());
__allocated_ptr<__allocator_type> __guard_ptr{ __a, this };
this->~_Sp_counted_deleter();
    }

    virtual void*
    _M_get_deleter(const std::type_info& __ti) noexcept
    {
484#if __cpp_rtti
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2400. shared_ptr's get_deleter() should use addressof()
      return __ti == typeid(_Deleter)
 ? std::__addressof(_M_impl._M_del())
 : nullptr;
490#else
      return nullptr;
492#endif
    }

  private:
    _Impl _M_impl;
  };

// helpers for make_shared / allocate_shared

struct _Sp_make_shared_tag
{
private:
  template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
    friend class _Sp_counted_ptr_inplace;

  static const type_info&
  _S_ti() noexcept _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
  {
    alignas(type_info) static constexpr char __tag[sizeof(type_info)] = { };
    return reinterpret_cast<const type_info&>(__tag);
  }
};

template<typename _Alloc>
  struct _Sp_alloc_shared_tag
  {
    const _Alloc& _M_a;
  };

template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
  class _Sp_counted_ptr_inplace final : public _Sp_counted_base<_Lp>
  {
    class _Impl : _Sp_ebo_helper<0, _Alloc>
    {
typedef _Sp_ebo_helper<0, _Alloc>	_A_base;

    public:
explicit _Impl(_Alloc __a) noexcept : _A_base(__a) { }

_Alloc& _M_alloc() noexcept { return _A_base::_S_get(*this); }

__gnu_cxx::__aligned_buffer<_Tp> _M_storage;
    };

  public:
    using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_ptr_inplace>;

    template<typename... _Args>
_Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args)
: _M_impl(__a)
{
 // _GLIBCXX_RESOLVE_LIB_DEFECTS
 // 2070.  allocate_shared should use allocator_traits<A>::construct
 allocator_traits<_Alloc>::construct(__a, _M_ptr(),
     std::forward<_Args>(__args)...); // might throw
}

    ~_Sp_counted_ptr_inplace() noexcept { }

    virtual void
    _M_dispose() noexcept
    {
allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr());
    }

    // Override because the allocator needs to know the dynamic type
    virtual void
    _M_destroy() noexcept
    {
__allocator_type __a(_M_impl._M_alloc());
__allocated_ptr<__allocator_type> __guard_ptr{ __a, this };
this->~_Sp_counted_ptr_inplace();
    }

  private:
    friend class __shared_count<_Lp>; // To be able to call _M_ptr().

    // No longer used, but code compiled against old libstdc++ headers
    // might still call it from __shared_ptr ctor to get the pointer out.
    virtual void*
    _M_get_deleter(const std::type_info& __ti) noexcept override
    {
// Check for the fake type_info first, so we don't try to access it
// as a real type_info object.
if (&__ti == &_Sp_make_shared_tag::_S_ti())
 return const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());
578#if __cpp_rtti
// Callers compiled with old libstdc++ headers and RTTI enabled
// might pass this instead:
else if (__ti == typeid(_Sp_make_shared_tag))
 return const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());
583#else
// Cannot detect a real type_info object. If the linker keeps a
// definition of this function compiled with -fno-rtti then callers
// that have RTTI enabled and pass a real type_info object will get
// a null pointer returned.
588#endif
return nullptr;
    }

    _Tp* _M_ptr() noexcept { return _M_impl._M_storage._M_ptr(); }

    _Impl _M_impl;
  };

// The default deleter for shared_ptr<T[]> and shared_ptr<T[N]>.
struct __sp_array_delete
{
  template<typename _Yp>
    void operator()(_Yp* __p) const { delete[] __p; }
};

template<_Lock_policy _Lp>
  class __shared_count
  {
    template<typename _Tp>
struct __not_alloc_shared_tag { using type = void; };

    template<typename _Tp>
struct __not_alloc_shared_tag<_Sp_alloc_shared_tag<_Tp>> { };

  public:
    constexpr __shared_count() noexcept : _M_pi(0)
    { }

    template<typename _Ptr>
      explicit
__shared_count(_Ptr __p) : _M_pi(0)
{
 __tryif (true)
8
←
Taking true branch→
   {
     _M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p);
9
←
Memory is allocated→
   }
 __catch(...)if (false)
10
←
Taking false branch→
   {
     delete __p;
     __throw_exception_again;
   }
}

    template<typename _Ptr>
__shared_count(_Ptr __p, /* is_array = */ false_type)
: __shared_count(__p)
7
←
Calling constructor for '__shared_count<__gnu_cxx::_S_atomic>'→
11
←
Returning from constructor for '__shared_count<__gnu_cxx::_S_atomic>'→
{ }

    template<typename _Ptr>
__shared_count(_Ptr __p, /* is_array = */ true_type)
: __shared_count(__p, __sp_array_delete{}, allocator<void>())
{ }

    template<typename _Ptr, typename _Deleter,
      typename = typename __not_alloc_shared_tag<_Deleter>::type>
__shared_count(_Ptr __p, _Deleter __d)
: __shared_count(__p, std::move(__d), allocator<void>())
{ }

    template<typename _Ptr, typename _Deleter, typename _Alloc,
      typename = typename __not_alloc_shared_tag<_Deleter>::type>
__shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0)
{
 typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
 __tryif (true)
   {
     typename _Sp_cd_type::__allocator_type __a2(__a);
     auto __guard = std::__allocate_guarded(__a2);
     _Sp_cd_type* __mem = __guard.get();
     ::new (__mem) _Sp_cd_type(__p, std::move(__d), std::move(__a));
     _M_pi = __mem;
     __guard = nullptr;
   }
 __catch(...)if (false)
   {
     __d(__p); // Call _Deleter on __p.
     __throw_exception_again;
   }
}

    template<typename _Tp, typename _Alloc, typename... _Args>
__shared_count(_Tp*& __p, _Sp_alloc_shared_tag<_Alloc> __a,
       _Args&&... __args)
{
 typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type;
 typename _Sp_cp_type::__allocator_type __a2(__a._M_a);
 auto __guard = std::__allocate_guarded(__a2);
 _Sp_cp_type* __mem = __guard.get();
 auto __pi = ::new (__mem)
   _Sp_cp_type(__a._M_a, std::forward<_Args>(__args)...);
 __guard = nullptr;
 _M_pi = __pi;
 __p = __pi->_M_ptr();
}

684#if _GLIBCXX_USE_DEPRECATED1
685#pragma GCC diagnostic push
686#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    // Special case for auto_ptr<_Tp> to provide the strong guarantee.
    template<typename _Tp>
      explicit
__shared_count(std::auto_ptr<_Tp>&& __r);
691#pragma GCC diagnostic pop
692#endif

    // Special case for unique_ptr<_Tp,_Del> to provide the strong guarantee.
    template<typename _Tp, typename _Del>
      explicit
__shared_count(std::unique_ptr<_Tp, _Del>&& __r) : _M_pi(0)
{
 // _GLIBCXX_RESOLVE_LIB_DEFECTS
 // 2415. Inconsistency between unique_ptr and shared_ptr
 if (__r.get() == nullptr)
   return;

 using _Ptr = typename unique_ptr<_Tp, _Del>::pointer;
 using _Del2 = typename conditional<is_reference<_Del>::value,
     reference_wrapper<typename remove_reference<_Del>::type>,
     _Del>::type;
 using _Sp_cd_type
   = _Sp_counted_deleter<_Ptr, _Del2, allocator<void>, _Lp>;
 using _Alloc = allocator<_Sp_cd_type>;
 using _Alloc_traits = allocator_traits<_Alloc>;
 _Alloc __a;
 _Sp_cd_type* __mem = _Alloc_traits::allocate(__a, 1);
 _Alloc_traits::construct(__a, __mem, __r.release(),
		   __r.get_deleter());  // non-throwing
 _M_pi = __mem;
}

    // Throw bad_weak_ptr when __r._M_get_use_count() == 0.
    explicit __shared_count(const __weak_count<_Lp>& __r);

    // Does not throw if __r._M_get_use_count() == 0, caller must check.
    explicit __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t);

    ~__shared_count() noexcept
    {
if (_M_pi != nullptr)
 _M_pi->_M_release();
    }

    __shared_count(const __shared_count& __r) noexcept
    : _M_pi(__r._M_pi)
    {
if (_M_pi != 0)
 _M_pi->_M_add_ref_copy();
    }

    __shared_count&
    operator=(const __shared_count& __r) noexcept
    {
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
if (__tmp != _M_pi)
 {
   if (__tmp != 0)
     __tmp->_M_add_ref_copy();
   if (_M_pi != 0)
     _M_pi->_M_release();
   _M_pi = __tmp;
 }
return *this;
    }

    void
    _M_swap(__shared_count& __r) noexcept
    {
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
__r._M_pi = _M_pi;
_M_pi = __tmp;
    }

    long
    _M_get_use_count() const noexcept
    { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }

    bool
    _M_unique() const noexcept
    { return this->_M_get_use_count() == 1; }

    void*
    _M_get_deleter(const std::type_info& __ti) const noexcept
    { return _M_pi ? _M_pi->_M_get_deleter(__ti) : nullptr; }

    bool
    _M_less(const __shared_count& __rhs) const noexcept
    { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }

    bool
    _M_less(const __weak_count<_Lp>& __rhs) const noexcept
    { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }

    // Friend function injected into enclosing namespace and found by ADL
    friend inline bool
    operator==(const __shared_count& __a, const __shared_count& __b) noexcept
    { return __a._M_pi == __b._M_pi; }

  private:
    friend class __weak_count<_Lp>;

    _Sp_counted_base<_Lp>*  _M_pi;
  };


template<_Lock_policy _Lp>
  class __weak_count
  {
  public:
    constexpr __weak_count() noexcept : _M_pi(nullptr)
    { }

    __weak_count(const __shared_count<_Lp>& __r) noexcept
    : _M_pi(__r._M_pi)
    {
if (_M_pi != nullptr)
 _M_pi->_M_weak_add_ref();
    }

    __weak_count(const __weak_count& __r) noexcept
    : _M_pi(__r._M_pi)
    {
if (_M_pi != nullptr)
 _M_pi->_M_weak_add_ref();
    }

    __weak_count(__weak_count&& __r) noexcept
    : _M_pi(__r._M_pi)
    { __r._M_pi = nullptr; }

    ~__weak_count() noexcept
    {
if (_M_pi != nullptr)
 _M_pi->_M_weak_release();
    }

    __weak_count&
    operator=(const __shared_count<_Lp>& __r) noexcept
    {
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
if (__tmp != nullptr)
 __tmp->_M_weak_add_ref();
if (_M_pi != nullptr)
 _M_pi->_M_weak_release();
_M_pi = __tmp;
return *this;
    }

    __weak_count&
    operator=(const __weak_count& __r) noexcept
    {
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
if (__tmp != nullptr)
 __tmp->_M_weak_add_ref();
if (_M_pi != nullptr)
 _M_pi->_M_weak_release();
_M_pi = __tmp;
return *this;
    }

    __weak_count&
    operator=(__weak_count&& __r) noexcept
    {
if (_M_pi != nullptr)
 _M_pi->_M_weak_release();
_M_pi = __r._M_pi;
      __r._M_pi = nullptr;
return *this;
    }

    void
    _M_swap(__weak_count& __r) noexcept
    {
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
__r._M_pi = _M_pi;
_M_pi = __tmp;
    }

    long
    _M_get_use_count() const noexcept
    { return _M_pi != nullptr ? _M_pi->_M_get_use_count() : 0; }

    bool
    _M_less(const __weak_count& __rhs) const noexcept
    { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }

    bool
    _M_less(const __shared_count<_Lp>& __rhs) const noexcept
    { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }

    // Friend function injected into enclosing namespace and found by ADL
    friend inline bool
    operator==(const __weak_count& __a, const __weak_count& __b) noexcept
    { return __a._M_pi == __b._M_pi; }

  private:
    friend class __shared_count<_Lp>;

    _Sp_counted_base<_Lp>*  _M_pi;
  };

// Now that __weak_count is defined we can define this constructor:
template<_Lock_policy _Lp>
  inline
  __shared_count<_Lp>::__shared_count(const __weak_count<_Lp>& __r)
  : _M_pi(__r._M_pi)
  {
    if (_M_pi != nullptr)
_M_pi->_M_add_ref_lock();
    else
__throw_bad_weak_ptr();
  }

// Now that __weak_count is defined we can define this constructor:
template<_Lock_policy _Lp>
  inline
  __shared_count<_Lp>::
  __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t)
  : _M_pi(__r._M_pi)
  {
    if (_M_pi != nullptr)
if (!_M_pi->_M_add_ref_lock_nothrow())
 _M_pi = nullptr;
  }

913#define __cpp_lib_shared_ptr_arrays201603 201603

// Helper traits for shared_ptr of array:

// A pointer type Y* is said to be compatible with a pointer type T* when
// either Y* is convertible to T* or Y is U[N] and T is U cv [].
template<typename _Yp_ptr, typename _Tp_ptr>
  struct __sp_compatible_with
  : false_type
  { };

template<typename _Yp, typename _Tp>
  struct __sp_compatible_with<_Yp*, _Tp*>
  : is_convertible<_Yp*, _Tp*>::type
  { };

template<typename _Up, size_t _Nm>
  struct __sp_compatible_with<_Up(*)[_Nm], _Up(*)[]>
  : true_type
  { };

template<typename _Up, size_t _Nm>
  struct __sp_compatible_with<_Up(*)[_Nm], const _Up(*)[]>
  : true_type
  { };

template<typename _Up, size_t _Nm>
  struct __sp_compatible_with<_Up(*)[_Nm], volatile _Up(*)[]>
  : true_type
  { };

template<typename _Up, size_t _Nm>
  struct __sp_compatible_with<_Up(*)[_Nm], const volatile _Up(*)[]>
  : true_type
  { };

// Test conversion from Y(*)[N] to U(*)[N] without forming invalid type Y[N].
template<typename _Up, size_t _Nm, typename _Yp, typename = void>
  struct __sp_is_constructible_arrN
  : false_type
  { };

template<typename _Up, size_t _Nm, typename _Yp>
  struct __sp_is_constructible_arrN<_Up, _Nm, _Yp, __void_t<_Yp[_Nm]>>
  : is_convertible<_Yp(*)[_Nm], _Up(*)[_Nm]>::type
  { };

// Test conversion from Y(*)[] to U(*)[] without forming invalid type Y[].
template<typename _Up, typename _Yp, typename = void>
  struct __sp_is_constructible_arr
  : false_type
  { };

template<typename _Up, typename _Yp>
  struct __sp_is_constructible_arr<_Up, _Yp, __void_t<_Yp[]>>
  : is_convertible<_Yp(*)[], _Up(*)[]>::type
  { };

// Trait to check if shared_ptr<T> can be constructed from Y*.
template<typename _Tp, typename _Yp>
  struct __sp_is_constructible;

// When T is U[N], Y(*)[N] shall be convertible to T*;
template<typename _Up, size_t _Nm, typename _Yp>
  struct __sp_is_constructible<_Up[_Nm], _Yp>
  : __sp_is_constructible_arrN<_Up, _Nm, _Yp>::type
  { };

// when T is U[], Y(*)[] shall be convertible to T*;
template<typename _Up, typename _Yp>
  struct __sp_is_constructible<_Up[], _Yp>
  : __sp_is_constructible_arr<_Up, _Yp>::type
  { };

// otherwise, Y* shall be convertible to T*.
template<typename _Tp, typename _Yp>
  struct __sp_is_constructible
  : is_convertible<_Yp*, _Tp*>::type
  { };


// Define operator* and operator-> for shared_ptr<T>.
template<typename _Tp, _Lock_policy _Lp,
  bool = is_array<_Tp>::value, bool = is_void<_Tp>::value>
  class __shared_ptr_access
  {
  public:
    using element_type = _Tp;

    element_type&
    operator*() const noexcept
    {
__glibcxx_assert(_M_get() != nullptr);
return *_M_get();
    }

    element_type*
    operator->() const noexcept
    {
_GLIBCXX_DEBUG_PEDASSERT(_M_get() != nullptr);
return _M_get();
    }

  private:
    element_type*
    _M_get() const noexcept
    { return static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get(); }
  };

// Define operator-> for shared_ptr<cv void>.
template<typename _Tp, _Lock_policy _Lp>
  class __shared_ptr_access<_Tp, _Lp, false, true>
  {
  public:
    using element_type = _Tp;

    element_type*
    operator->() const noexcept
    {
auto __ptr = static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get();
_GLIBCXX_DEBUG_PEDASSERT(__ptr != nullptr);
return __ptr;
    }
  };

// Define operator[] for shared_ptr<T[]> and shared_ptr<T[N]>.
template<typename _Tp, _Lock_policy _Lp>
  class __shared_ptr_access<_Tp, _Lp, true, false>
  {
  public:
    using element_type = typename remove_extent<_Tp>::type;

1045#if __cplusplus201703L <= 201402L
    [[__deprecated__("shared_ptr<T[]>::operator* is absent from C++17")]]
    element_type&
    operator*() const noexcept
    {
__glibcxx_assert(_M_get() != nullptr);
return *_M_get();
    }

    [[__deprecated__("shared_ptr<T[]>::operator-> is absent from C++17")]]
    element_type*
    operator->() const noexcept
    {
_GLIBCXX_DEBUG_PEDASSERT(_M_get() != nullptr);
return _M_get();
    }
1061#endif

    element_type&
    operator[](ptrdiff_t __i) const
    {
__glibcxx_assert(_M_get() != nullptr);
__glibcxx_assert(!extent<_Tp>::value || __i < extent<_Tp>::value);
return _M_get()[__i];
    }

  private:
    element_type*
    _M_get() const noexcept
    { return static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get(); }
  };

template<typename _Tp, _Lock_policy _Lp>
  class __shared_ptr
  : public __shared_ptr_access<_Tp, _Lp>
  {
  public:
    using element_type = typename remove_extent<_Tp>::type;

  private:
    // Constraint for taking ownership of a pointer of type _Yp*:
    template<typename _Yp>
using _SafeConv
 = typename enable_if<__sp_is_constructible<_Tp, _Yp>::value>::type;

    // Constraint for construction from shared_ptr and weak_ptr:
    template<typename _Yp, typename _Res = void>
using _Compatible = typename
 enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type;

    // Constraint for assignment from shared_ptr and weak_ptr:
    template<typename _Yp>
using _Assignable = _Compatible<_Yp, __shared_ptr&>;

    // Constraint for construction from unique_ptr:
    template<typename _Yp, typename _Del, typename _Res = void,
      typename _Ptr = typename unique_ptr<_Yp, _Del>::pointer>
using _UniqCompatible = typename enable_if<__and_<
 __sp_compatible_with<_Yp*, _Tp*>, is_convertible<_Ptr, element_type*>
 >::value, _Res>::type;

    // Constraint for assignment from unique_ptr:
    template<typename _Yp, typename _Del>
using _UniqAssignable = _UniqCompatible<_Yp, _Del, __shared_ptr&>;

  public:

1112#if __cplusplus201703L > 201402L
    using weak_type = __weak_ptr<_Tp, _Lp>;
1114#endif

    constexpr __shared_ptr() noexcept
    : _M_ptr(0), _M_refcount()
    { }

    template<typename _Yp, typename = _SafeConv<_Yp>>
explicit
__shared_ptr(_Yp* __p)
: _M_ptr(__p), _M_refcount(__p, typename is_array<_Tp>::type())
6
←
Calling constructor for '__shared_count<__gnu_cxx::_S_atomic>'→
12
←
Returning from constructor for '__shared_count<__gnu_cxx::_S_atomic>'→
{
 static_assert( !is_void<_Yp>::value, "incomplete type" );
 static_assert( sizeof(_Yp) > 0, "incomplete type" );
 _M_enable_shared_from_this_with(__p);
}

    template<typename _Yp, typename _Deleter, typename = _SafeConv<_Yp>>
__shared_ptr(_Yp* __p, _Deleter __d)
: _M_ptr(__p), _M_refcount(__p, std::move(__d))
{
 static_assert(__is_invocable<_Deleter&, _Yp*&>::value,
     "deleter expression d(p) is well-formed");
 _M_enable_shared_from_this_with(__p);
}

    template<typename _Yp, typename _Deleter, typename _Alloc,
      typename = _SafeConv<_Yp>>
__shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a)
: _M_ptr(__p), _M_refcount(__p, std::move(__d), std::move(__a))
{
 static_assert(__is_invocable<_Deleter&, _Yp*&>::value,
     "deleter expression d(p) is well-formed");
 _M_enable_shared_from_this_with(__p);
}

    template<typename _Deleter>
__shared_ptr(nullptr_t __p, _Deleter __d)
: _M_ptr(0), _M_refcount(__p, std::move(__d))
{ }

    template<typename _Deleter, typename _Alloc>
      __shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
: _M_ptr(0), _M_refcount(__p, std::move(__d), std::move(__a))
{ }

    template<typename _Yp>
__shared_ptr(const __shared_ptr<_Yp, _Lp>& __r,
     element_type* __p) noexcept
: _M_ptr(__p), _M_refcount(__r._M_refcount) // never throws
{ }

    __shared_ptr(const __shared_ptr&) noexcept = default;
    __shared_ptr& operator=(const __shared_ptr&) noexcept = default;
    ~__shared_ptr() = default;

    template<typename _Yp, typename = _Compatible<_Yp>>
__shared_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept
: _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
{ }

    __shared_ptr(__shared_ptr&& __r) noexcept
    : _M_ptr(__r._M_ptr), _M_refcount()
    {
_M_refcount._M_swap(__r._M_refcount);
__r._M_ptr = 0;
    }

    template<typename _Yp, typename = _Compatible<_Yp>>
__shared_ptr(__shared_ptr<_Yp, _Lp>&& __r) noexcept
: _M_ptr(__r._M_ptr), _M_refcount()
{
 _M_refcount._M_swap(__r._M_refcount);
 __r._M_ptr = 0;
}

    template<typename _Yp, typename = _Compatible<_Yp>>
explicit __shared_ptr(const __weak_ptr<_Yp, _Lp>& __r)
: _M_refcount(__r._M_refcount) // may throw
{
 // It is now safe to copy __r._M_ptr, as
 // _M_refcount(__r._M_refcount) did not throw.
 _M_ptr = __r._M_ptr;
}

    // If an exception is thrown this constructor has no effect.
    template<typename _Yp, typename _Del,
      typename = _UniqCompatible<_Yp, _Del>>
__shared_ptr(unique_ptr<_Yp, _Del>&& __r)
: _M_ptr(__r.get()), _M_refcount()
{
 auto __raw = __to_address(__r.get());
 _M_refcount = __shared_count<_Lp>(std::move(__r));
 _M_enable_shared_from_this_with(__raw);
}

1209#if __cplusplus201703L <= 201402L && _GLIBCXX_USE_DEPRECATED1
  protected:
    // If an exception is thrown this constructor has no effect.
    template<typename _Tp1, typename _Del,
      typename enable_if<__and_<
 __not_<is_array<_Tp>>, is_array<_Tp1>,
        is_convertible<typename unique_ptr<_Tp1, _Del>::pointer, _Tp*>
      >::value, bool>::type = true>
__shared_ptr(unique_ptr<_Tp1, _Del>&& __r, __sp_array_delete)
: _M_ptr(__r.get()), _M_refcount()
{
 auto __raw = __to_address(__r.get());
 _M_refcount = __shared_count<_Lp>(std::move(__r));
 _M_enable_shared_from_this_with(__raw);
}
  public:
1225#endif

1227#if _GLIBCXX_USE_DEPRECATED1
1228#pragma GCC diagnostic push
1229#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    // Postcondition: use_count() == 1 and __r.get() == 0
    template<typename _Yp, typename = _Compatible<_Yp>>
__shared_ptr(auto_ptr<_Yp>&& __r);
1233#pragma GCC diagnostic pop
1234#endif

    constexpr __shared_ptr(nullptr_t) noexcept : __shared_ptr() { }

    template<typename _Yp>
_Assignable<_Yp>
operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept
{
 _M_ptr = __r._M_ptr;
 _M_refcount = __r._M_refcount; // __shared_count::op= doesn't throw
 return *this;
}

1247#if _GLIBCXX_USE_DEPRECATED1
1248#pragma GCC diagnostic push
1249#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    template<typename _Yp>
_Assignable<_Yp>
operator=(auto_ptr<_Yp>&& __r)
{
 __shared_ptr(std::move(__r)).swap(*this);
 return *this;
}
1257#pragma GCC diagnostic pop
1258#endif

    __shared_ptr&
    operator=(__shared_ptr&& __r) noexcept
    {
__shared_ptr(std::move(__r)).swap(*this);
return *this;
    }

    template<class _Yp>
_Assignable<_Yp>
operator=(__shared_ptr<_Yp, _Lp>&& __r) noexcept
{
 __shared_ptr(std::move(__r)).swap(*this);
 return *this;
}

    template<typename _Yp, typename _Del>
_UniqAssignable<_Yp, _Del>
operator=(unique_ptr<_Yp, _Del>&& __r)
{
 __shared_ptr(std::move(__r)).swap(*this);
 return *this;
}

    void
    reset() noexcept
    { __shared_ptr().swap(*this); }

    template<typename _Yp>
_SafeConv<_Yp>
reset(_Yp* __p) // _Yp must be complete.
{
 // Catch self-reset errors.
 __glibcxx_assert(__p == 0 || __p != _M_ptr);
 __shared_ptr(__p).swap(*this);
}

    template<typename _Yp, typename _Deleter>
_SafeConv<_Yp>
reset(_Yp* __p, _Deleter __d)
{ __shared_ptr(__p, std::move(__d)).swap(*this); }

    template<typename _Yp, typename _Deleter, typename _Alloc>
_SafeConv<_Yp>
reset(_Yp* __p, _Deleter __d, _Alloc __a)
      { __shared_ptr(__p, std::move(__d), std::move(__a)).swap(*this); }

    element_type*
    get() const noexcept
    { return _M_ptr; }

    explicit operator bool() const // never throws
    { return _M_ptr == 0 ? false : true; }

    bool
    unique() const noexcept
    { return _M_refcount._M_unique(); }

    long
    use_count() const noexcept
    { return _M_refcount._M_get_use_count(); }

    void
    swap(__shared_ptr<_Tp, _Lp>& __other) noexcept
    {
std::swap(_M_ptr, __other._M_ptr);
_M_refcount._M_swap(__other._M_refcount);
    }

    template<typename _Tp1>
bool
owner_before(__shared_ptr<_Tp1, _Lp> const& __rhs) const noexcept
{ return _M_refcount._M_less(__rhs._M_refcount); }

    template<typename _Tp1>
bool
owner_before(__weak_ptr<_Tp1, _Lp> const& __rhs) const noexcept
{ return _M_refcount._M_less(__rhs._M_refcount); }

  protected:
    // This constructor is non-standard, it is used by allocate_shared.
    template<typename _Alloc, typename... _Args>
__shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args)
: _M_ptr(), _M_refcount(_M_ptr, __tag, std::forward<_Args>(__args)...)
{ _M_enable_shared_from_this_with(_M_ptr); }

    template<typename _Tp1, _Lock_policy _Lp1, typename _Alloc,
      typename... _Args>
friend __shared_ptr<_Tp1, _Lp1>
__allocate_shared(const _Alloc& __a, _Args&&... __args);

    // This constructor is used by __weak_ptr::lock() and
    // shared_ptr::shared_ptr(const weak_ptr&, std::nothrow_t).
    __shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t)
    : _M_refcount(__r._M_refcount, std::nothrow)
    {
_M_ptr = _M_refcount._M_get_use_count() ? __r._M_ptr : nullptr;
    }

    friend class __weak_ptr<_Tp, _Lp>;

  private:

    template<typename _Yp>
using __esft_base_t = decltype(__enable_shared_from_this_base(
     std::declval<const __shared_count<_Lp>&>(),
     std::declval<_Yp*>()));

    // Detect an accessible and unambiguous enable_shared_from_this base.
    template<typename _Yp, typename = void>
struct __has_esft_base
: false_type { };

    template<typename _Yp>
struct __has_esft_base<_Yp, __void_t<__esft_base_t<_Yp>>>
: __not_<is_array<_Tp>> { }; // No enable shared_from_this for arrays

    template<typename _Yp, typename _Yp2 = typename remove_cv<_Yp>::type>
typename enable_if<__has_esft_base<_Yp2>::value>::type
_M_enable_shared_from_this_with(_Yp* __p) noexcept
{
 if (auto __base = __enable_shared_from_this_base(_M_refcount, __p))
   __base->_M_weak_assign(const_cast<_Yp2*>(__p), _M_refcount);
}

    template<typename _Yp, typename _Yp2 = typename remove_cv<_Yp>::type>
typename enable_if<!__has_esft_base<_Yp2>::value>::type
_M_enable_shared_from_this_with(_Yp*) noexcept
{ }

    void*
    _M_get_deleter(const std::type_info& __ti) const noexcept
    { return _M_refcount._M_get_deleter(__ti); }

    template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
    template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;

    template<typename _Del, typename _Tp1, _Lock_policy _Lp1>
friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&) noexcept;

    template<typename _Del, typename _Tp1>
friend _Del* get_deleter(const shared_ptr<_Tp1>&) noexcept;

    element_type*	   _M_ptr;         // Contained pointer.
    __shared_count<_Lp>  _M_refcount;    // Reference counter.
  };


// 20.7.2.2.7 shared_ptr comparisons
template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  inline bool
  operator==(const __shared_ptr<_Tp1, _Lp>& __a,
      const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  { return __a.get() == __b.get(); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator==(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  { return !__a; }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator==(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  { return !__a; }

template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  inline bool
  operator!=(const __shared_ptr<_Tp1, _Lp>& __a,
      const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  { return __a.get() != __b.get(); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator!=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  { return (bool)__a; }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator!=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  { return (bool)__a; }

template<typename _Tp, typename _Up, _Lock_policy _Lp>
  inline bool
  operator<(const __shared_ptr<_Tp, _Lp>& __a,
     const __shared_ptr<_Up, _Lp>& __b) noexcept
  {
    using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type;
    using _Up_elt = typename __shared_ptr<_Up, _Lp>::element_type;
    using _Vp = typename common_type<_Tp_elt*, _Up_elt*>::type;
    return less<_Vp>()(__a.get(), __b.get());
  }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator<(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  {
    using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type;
    return less<_Tp_elt*>()(__a.get(), nullptr);
  }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator<(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  {
    using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type;
    return less<_Tp_elt*>()(nullptr, __a.get());
  }

template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  inline bool
  operator<=(const __shared_ptr<_Tp1, _Lp>& __a,
      const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  { return !(__b < __a); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator<=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  { return !(nullptr < __a); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator<=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  { return !(__a < nullptr); }

template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  inline bool
  operator>(const __shared_ptr<_Tp1, _Lp>& __a,
     const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  { return (__b < __a); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator>(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  { return nullptr < __a; }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator>(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  { return __a < nullptr; }

template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  inline bool
  operator>=(const __shared_ptr<_Tp1, _Lp>& __a,
      const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  { return !(__a < __b); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator>=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  { return !(__a < nullptr); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator>=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  { return !(nullptr < __a); }

template<typename _Sp>
  struct _Sp_less : public binary_function<_Sp, _Sp, bool>
  {
    bool
    operator()(const _Sp& __lhs, const _Sp& __rhs) const noexcept
    {
typedef typename _Sp::element_type element_type;
return std::less<element_type*>()(__lhs.get(), __rhs.get());
    }
  };

template<typename _Tp, _Lock_policy _Lp>
  struct less<__shared_ptr<_Tp, _Lp>>
  : public _Sp_less<__shared_ptr<_Tp, _Lp>>
  { };

// 20.7.2.2.8 shared_ptr specialized algorithms.
template<typename _Tp, _Lock_policy _Lp>
  inline void
  swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) noexcept
  { __a.swap(__b); }

// 20.7.2.2.9 shared_ptr casts

// The seemingly equivalent code:
// shared_ptr<_Tp, _Lp>(static_cast<_Tp*>(__r.get()))
// will eventually result in undefined behaviour, attempting to
// delete the same object twice.
/// static_pointer_cast
template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
  inline __shared_ptr<_Tp, _Lp>
  static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  {
    using _Sp = __shared_ptr<_Tp, _Lp>;
    return _Sp(__r, static_cast<typename _Sp::element_type*>(__r.get()));
  }

// The seemingly equivalent code:
// shared_ptr<_Tp, _Lp>(const_cast<_Tp*>(__r.get()))
// will eventually result in undefined behaviour, attempting to
// delete the same object twice.
/// const_pointer_cast
template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
  inline __shared_ptr<_Tp, _Lp>
  const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  {
    using _Sp = __shared_ptr<_Tp, _Lp>;
    return _Sp(__r, const_cast<typename _Sp::element_type*>(__r.get()));
  }

// The seemingly equivalent code:
// shared_ptr<_Tp, _Lp>(dynamic_cast<_Tp*>(__r.get()))
// will eventually result in undefined behaviour, attempting to
// delete the same object twice.
/// dynamic_pointer_cast
template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
  inline __shared_ptr<_Tp, _Lp>
  dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  {
    using _Sp = __shared_ptr<_Tp, _Lp>;
    if (auto* __p = dynamic_cast<typename _Sp::element_type*>(__r.get()))
return _Sp(__r, __p);
    return _Sp();
  }

1580#if __cplusplus201703L > 201402L
template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
  inline __shared_ptr<_Tp, _Lp>
  reinterpret_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  {
    using _Sp = __shared_ptr<_Tp, _Lp>;
    return _Sp(__r, reinterpret_cast<typename _Sp::element_type*>(__r.get()));
  }
1588#endif

template<typename _Tp, _Lock_policy _Lp>
  class __weak_ptr
  {
    template<typename _Yp, typename _Res = void>
using _Compatible = typename
 enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type;

    // Constraint for assignment from shared_ptr and weak_ptr:
    template<typename _Yp>
using _Assignable = _Compatible<_Yp, __weak_ptr&>;

  public:
    using element_type = typename remove_extent<_Tp>::type;

    constexpr __weak_ptr() noexcept
    : _M_ptr(nullptr), _M_refcount()
    { }

    __weak_ptr(const __weak_ptr&) noexcept = default;

    ~__weak_ptr() = default;

    // The "obvious" converting constructor implementation:
    //
    //  template<typename _Tp1>
    //    __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
    //    : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws
    //    { }
    //
    // has a serious problem.
    //
    //  __r._M_ptr may already have been invalidated. The _M_ptr(__r._M_ptr)
    //  conversion may require access to *__r._M_ptr (virtual inheritance).
    //
    // It is not possible to avoid spurious access violations since
    // in multithreaded programs __r._M_ptr may be invalidated at any point.
    template<typename _Yp, typename = _Compatible<_Yp>>
__weak_ptr(const __weak_ptr<_Yp, _Lp>& __r) noexcept
: _M_refcount(__r._M_refcount)
      { _M_ptr = __r.lock().get(); }

    template<typename _Yp, typename = _Compatible<_Yp>>
__weak_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept
: _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
{ }

    __weak_ptr(__weak_ptr&& __r) noexcept
    : _M_ptr(__r._M_ptr), _M_refcount(std::move(__r._M_refcount))
    { __r._M_ptr = nullptr; }

    template<typename _Yp, typename = _Compatible<_Yp>>
__weak_ptr(__weak_ptr<_Yp, _Lp>&& __r) noexcept
: _M_ptr(__r.lock().get()), _M_refcount(std::move(__r._M_refcount))
      { __r._M_ptr = nullptr; }

    __weak_ptr&
    operator=(const __weak_ptr& __r) noexcept = default;

    template<typename _Yp>
_Assignable<_Yp>
operator=(const __weak_ptr<_Yp, _Lp>& __r) noexcept
{
 _M_ptr = __r.lock().get();
 _M_refcount = __r._M_refcount;
 return *this;
}

    template<typename _Yp>
_Assignable<_Yp>
operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept
{
 _M_ptr = __r._M_ptr;
 _M_refcount = __r._M_refcount;
 return *this;
}

    __weak_ptr&
    operator=(__weak_ptr&& __r) noexcept
    {
_M_ptr = __r._M_ptr;
_M_refcount = std::move(__r._M_refcount);
__r._M_ptr = nullptr;
return *this;
    }

    template<typename _Yp>
_Assignable<_Yp>
operator=(__weak_ptr<_Yp, _Lp>&& __r) noexcept
{
 _M_ptr = __r.lock().get();
 _M_refcount = std::move(__r._M_refcount);
 __r._M_ptr = nullptr;
 return *this;
}

    __shared_ptr<_Tp, _Lp>
    lock() const noexcept
    { return __shared_ptr<element_type, _Lp>(*this, std::nothrow); }

    long
    use_count() const noexcept
    { return _M_refcount._M_get_use_count(); }

    bool
    expired() const noexcept
    { return _M_refcount._M_get_use_count() == 0; }

    template<typename _Tp1>
bool
owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const noexcept
{ return _M_refcount._M_less(__rhs._M_refcount); }

    template<typename _Tp1>
bool
owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const noexcept
{ return _M_refcount._M_less(__rhs._M_refcount); }

    void
    reset() noexcept
    { __weak_ptr().swap(*this); }

    void
    swap(__weak_ptr& __s) noexcept
    {
std::swap(_M_ptr, __s._M_ptr);
_M_refcount._M_swap(__s._M_refcount);
    }

  private:
    // Used by __enable_shared_from_this.
    void
    _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) noexcept
    {
if (use_count() == 0)
 {
   _M_ptr = __ptr;
   _M_refcount = __refcount;
 }
    }

    template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
    template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
    friend class __enable_shared_from_this<_Tp, _Lp>;
    friend class enable_shared_from_this<_Tp>;

    element_type*	 _M_ptr;         // Contained pointer.
    __weak_count<_Lp>  _M_refcount;    // Reference counter.
  };

// 20.7.2.3.6 weak_ptr specialized algorithms.
template<typename _Tp, _Lock_policy _Lp>
  inline void
  swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) noexcept
  { __a.swap(__b); }

template<typename _Tp, typename _Tp1>
  struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool>
  {
    bool
    operator()(const _Tp& __lhs, const _Tp& __rhs) const noexcept
    { return __lhs.owner_before(__rhs); }

    bool
    operator()(const _Tp& __lhs, const _Tp1& __rhs) const noexcept
    { return __lhs.owner_before(__rhs); }

    bool
    operator()(const _Tp1& __lhs, const _Tp& __rhs) const noexcept
    { return __lhs.owner_before(__rhs); }
  };

template<>
  struct _Sp_owner_less<void, void>
  {
    template<typename _Tp, typename _Up>
auto
operator()(const _Tp& __lhs, const _Up& __rhs) const noexcept
-> decltype(__lhs.owner_before(__rhs))
{ return __lhs.owner_before(__rhs); }

    using is_transparent = void;
  };

template<typename _Tp, _Lock_policy _Lp>
  struct owner_less<__shared_ptr<_Tp, _Lp>>
  : public _Sp_owner_less<__shared_ptr<_Tp, _Lp>, __weak_ptr<_Tp, _Lp>>
  { };

template<typename _Tp, _Lock_policy _Lp>
  struct owner_less<__weak_ptr<_Tp, _Lp>>
  : public _Sp_owner_less<__weak_ptr<_Tp, _Lp>, __shared_ptr<_Tp, _Lp>>
  { };


template<typename _Tp, _Lock_policy _Lp>
  class __enable_shared_from_this
  {
  protected:
    constexpr __enable_shared_from_this() noexcept { }

    __enable_shared_from_this(const __enable_shared_from_this&) noexcept { }

    __enable_shared_from_this&
    operator=(const __enable_shared_from_this&) noexcept
    { return *this; }

    ~__enable_shared_from_this() { }

  public:
    __shared_ptr<_Tp, _Lp>
    shared_from_this()
    { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); }

    __shared_ptr<const _Tp, _Lp>
    shared_from_this() const
    { return __shared_ptr<const _Tp, _Lp>(this->_M_weak_this); }

1807#if __cplusplus201703L > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
    __weak_ptr<_Tp, _Lp>
    weak_from_this() noexcept
    { return this->_M_weak_this; }

    __weak_ptr<const _Tp, _Lp>
    weak_from_this() const noexcept
    { return this->_M_weak_this; }
1815#endif

  private:
    template<typename _Tp1>
void
_M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const noexcept
{ _M_weak_this._M_assign(__p, __n); }

    friend const __enable_shared_from_this*
    __enable_shared_from_this_base(const __shared_count<_Lp>&,
		     const __enable_shared_from_this* __p)
    { return __p; }

    template<typename, _Lock_policy>
friend class __shared_ptr;

    mutable __weak_ptr<_Tp, _Lp>  _M_weak_this;
  };

template<typename _Tp, _Lock_policy _Lp, typename _Alloc, typename... _Args>
  inline __shared_ptr<_Tp, _Lp>
  __allocate_shared(const _Alloc& __a, _Args&&... __args)
  {
    return __shared_ptr<_Tp, _Lp>(_Sp_alloc_shared_tag<_Alloc>{__a},
		    std::forward<_Args>(__args)...);
  }

template<typename _Tp, _Lock_policy _Lp, typename... _Args>
  inline __shared_ptr<_Tp, _Lp>
  __make_shared(_Args&&... __args)
  {
    typedef typename std::remove_const<_Tp>::type _Tp_nc;
    return std::__allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(),
			      std::forward<_Args>(__args)...);
  }

/// std::hash specialization for __shared_ptr.
template<typename _Tp, _Lock_policy _Lp>
  struct hash<__shared_ptr<_Tp, _Lp>>
  : public __hash_base<size_t, __shared_ptr<_Tp, _Lp>>
  {
    size_t
    operator()(const __shared_ptr<_Tp, _Lp>& __s) const noexcept
    {
return hash<typename __shared_ptr<_Tp, _Lp>::element_type*>()(
   __s.get());
    }
  };

1864_GLIBCXX_END_NAMESPACE_VERSION
1865} // namespace

1867#endif // _SHARED_PTR_BASE_H