deps,lib,tools: remove jitless and lite modes

BUILDING.md

@@ -98,6 +98,9 @@ and libc version. The table below lists the support tier for each supported
 combination. A list of [supported compile toolchains](#supported-toolchains) is
 also supplied for tier 1 platforms.
 
+Node.js requires WebAssembly for built-in functionality, including `fetch()` and
+TypeScript support. JIT-less execution and V8 lite mode are not supported.
+
 **For production applications, run Node.js on supported platforms only (Tier 1 or 2).**
 
 Node.js does not support a platform version if a vendor has expired support

configure.py

@@ -1224,14 +1224,6 @@
     default=False,
     help='compile V8 with debug checks and runtime debugging features enabled')
 
-parser.add_argument('--v8-lite-mode',
-    action='store_true',
-    dest='v8_lite_mode',
-    default=False,
-    help='compile V8 in lite mode for constrained environments (lowers V8 '+
-         'memory footprint, but also implies no just-in-time compilation ' +
-         'support, thus much slower execution)')
-
 parser.add_argument('--v8-enable-object-print',
     action='store_true',
     dest='v8_enable_object_print',
@@ -1318,6 +1310,10 @@
 
 (options, args) = parser.parse_known_args()
 
+# Reject the removed option before forwarding unknown arguments to GYP.
+if any(arg.split('=', 1)[0] == '--v8-lite-mode' for arg in args):
+  parser.error('--v8-lite-mode is no longer supported; Node.js requires WebAssembly')
+
 # Expand ~ in the install prefix now, it gets written to multiple files.
 options.prefix = str(Path(options.prefix or '').expanduser())
 
@@ -2231,9 +2227,8 @@ def configure_library(lib, output, pkgname=None):
 def configure_v8(o, configs):
   set_configuration_variable(configs, 'v8_enable_v8_checks', release=0, debug=1)
 
-  o['variables']['v8_enable_webassembly'] = 0 if options.v8_lite_mode else 1
+  o['variables']['v8_enable_webassembly'] = 1
   o['variables']['v8_enable_javascript_promise_hooks'] = 1
-  o['variables']['v8_enable_lite_mode'] = 1 if options.v8_lite_mode else 0
   is_gdbjit_supported_arch = (
       'x64' in o['variables']['target_arch'] or
       'ia32' in o['variables']['target_arch'] or

deps/v8/src/flags/flag-definitions.h

@@ -451,8 +451,13 @@ DEFINE_NEG_IMPLICATION(stress_snapshot, incremental_marking)
 #define V8_LITE_MODE_BOOL false
 #endif
 
-DEFINE_BOOL(lite_mode, V8_LITE_MODE_BOOL,
-            "enables trade-off of performance for memory savings")
+// Node.js requires WebAssembly for built-in functionality, including fetch and
+// TypeScript. Retain the constants for V8 internals, but do not register these
+// unsupported modes with the flag parser.
+#if defined(FLAG_MODE_DECLARE)
+DEFINE_BOOL_READONLY(lite_mode, false,
+                     "enables trade-off of performance for memory savings")
+#endif
 
 // Lite mode implies other flags to trade-off performance for memory.
 DEFINE_IMPLICATION(lite_mode, jitless)
@@ -937,15 +942,14 @@ DEFINE_STRING(
     "Select which native code sequence to use for wasm trace instruction: "
     "default or cpuid")
 
-#ifdef V8_JITLESS
-#define V8_JITLESS_BOOL true
-DEFINE_BOOL_READONLY(jitless, true,
-                     "Disable runtime allocation of executable memory.")
-#else
+#if defined(V8_JITLESS) || defined(V8_LITE_MODE)
+#error Node.js does not support interpreter-only V8 builds.
+#endif
 #define V8_JITLESS_BOOL false
-DEFINE_BOOL(jitless, V8_LITE_MODE_BOOL,
-            "Disable runtime allocation of executable memory.")
-#endif  // V8_JITLESS
+#if defined(FLAG_MODE_DECLARE)
+DEFINE_BOOL_READONLY(jitless, false,
+                     "Disable runtime allocation of executable memory.")
+#endif
 
 // Jitless V8 has a few implications:
 // Field type tracking is only used by TurboFan.

deps/v8/src/flags/flags.cc

@@ -1042,6 +1042,10 @@ class ImplicationProcessor {
   bool EnforceImplications() {
     bool changed = false;
 
+    // Node.js retains these constants without exposing them as runtime flags.
+    const auto& jitless = v8_flags.jitless;
+    const auto& lite_mode = v8_flags.lite_mode;
+
     // For each flag, alias with a mutable reference so that implications don't
     // need the v8_flags prefix.
 #define FLAG_MODE_APPLY_NAME(name) \

doc/api/cli.md

@@ -2196,19 +2196,6 @@ added: v0.7.7
 
 Opens the REPL even if stdin does not appear to be a terminal.
 
-### `--jitless`
-
-<!-- YAML
-added: v12.0.0
--->
-
-> Stability: 1 - Experimental. This flag is inherited from V8 and is subject to
-> change upstream.
-
-Disable [runtime allocation of executable memory][jitless]. This may be
-required on some platforms for security reasons. It can also reduce attack
-surface on other platforms, but the performance impact may be severe.
-
 ### `--localstorage-file=file`
 
 <!-- YAML
@@ -4423,7 +4410,6 @@ V8 options that are allowed are:
 * `--enable-etw-stack-walking`
 * `--expose-gc`
 * `--interpreted-frames-native-stack`
-* `--jitless`
 * `--max-heap-size`
 * `--max-old-space-size`
 * `--max-semi-space-size`
@@ -4794,8 +4780,6 @@ documented here:
 
 ### `--interpreted-frames-native-stack`
 
-### `--jitless`
-
 ### `--max-heap-size`
 
 Specifies the maximum heap size (in megabytes) for the process.
@@ -4989,7 +4973,6 @@ node --stack-trace-limit=12 -p -e "Error.stackTraceLimit" # prints 12
 [environment_variables]: #environment-variables-1
 [filtering tests by name]: test.md#filtering-tests-by-name
 [global setup and teardown]: test.md#global-setup-and-teardown
-[jitless]: https://v8.dev/blog/jitless
 [libuv threadpool documentation]: https://docs.libuv.org/en/latest/threadpool.html
 [module compile cache]: module.md#module-compile-cache
 [preloading asynchronous module customization hooks]: module.md#registration-of-asynchronous-customization-hooks

doc/api/errors.md

@@ -3645,14 +3645,6 @@ The WASI instance has already started.
 
 The WASI instance has not been started.
 
-<a id="ERR_WEBASSEMBLY_NOT_SUPPORTED"></a>
-
-### `ERR_WEBASSEMBLY_NOT_SUPPORTED`
-
-A feature requiring WebAssembly was used, but WebAssembly is not supported or
-has been disabled in the current environment (for example, when running with
-`--jitless`).
-
 <a id="ERR_WEBASSEMBLY_RESPONSE"></a>
 
 ### `ERR_WEBASSEMBLY_RESPONSE`
@@ -4488,6 +4480,18 @@ The linker function returned a module for which linking has failed.
 
 The module must be successfully linked before instantiation.
 
+<a id="ERR_WEBASSEMBLY_NOT_SUPPORTED"></a>
+
+### `ERR_WEBASSEMBLY_NOT_SUPPORTED`
+
+<!-- YAML
+removed: REPLACEME
+-->
+
+A feature requiring WebAssembly was used in an environment where WebAssembly
+was unavailable. Node.js now requires WebAssembly and no longer supports
+JIT-less execution.
+
 <a id="ERR_WORKER_UNSUPPORTED_EXTENSION"></a>
 
 ### `ERR_WORKER_UNSUPPORTED_EXTENSION`

doc/node.1

@@ -1175,11 +1175,6 @@ See V8 Inspector integration for Node.js for further explanation on Node.js debu
 .It Fl i , Fl -interactive
 Opens the REPL even if stdin does not appear to be a terminal.
 .
-.It Fl -jitless
-Disable runtime allocation of executable memory. This may be
-required on some platforms for security reasons. It can also reduce attack
-surface on other platforms, but the performance impact may be severe.
-.
 .It Fl -localstorage-file Ns = Ns Ar file
 The file used to store \fBlocalStorage\fR data. If the file does not exist, it is
 created the first time \fBlocalStorage\fR is accessed. The same file may be shared
@@ -2536,8 +2531,6 @@ V8 options that are allowed are:
 .It
 \fB--interpreted-frames-native-stack\fR
 .It
-\fB--jitless\fR
-.It
 \fB--max-heap-size\fR
 .It
 \fB--max-old-space-size\fR

lib/eslint.config_partial.mjs

@@ -298,8 +298,8 @@ export default [
           name: 'URLSearchParams',
           message: "Use `const { URLSearchParams } = require('internal/url');` instead of the global.",
         },
-        // WebAssembly is not available in primordials because it can be
-        // disabled with --jitless CLI flag.
+        // WebAssembly is unavailable during snapshot building and must be
+        // accessed lazily at runtime.
         {
           name: 'WebAssembly',
           message: 'Use `const { WebAssembly } = globalThis;` instead of the global.',

lib/internal/errors.js

@@ -1981,9 +1981,6 @@ E('ERR_VM_MODULE_NOT_MODULE',
   'Provided module is not an instance of Module', Error);
 E('ERR_VM_MODULE_STATUS', 'Module status %s', Error);
 E('ERR_WASI_ALREADY_STARTED', 'WASI instance has already started', Error);
-E('ERR_WEBASSEMBLY_NOT_SUPPORTED',
-  'WebAssembly is not supported in this environment, but is required for %s',
-  Error);
 E('ERR_WEBASSEMBLY_RESPONSE', 'WebAssembly response %s', TypeError);
 E('ERR_WORKER_HANDLE_NOT_TRANSFERABLE',
   '%s cannot be transferred in its current state; it must be a freshly ' +

lib/internal/freeze_intrinsics.js

@@ -363,18 +363,16 @@ module.exports = function() {
     ArrayPrototypePush(intrinsics, SharedArrayBuffer);
   }
 
-  if (typeof WebAssembly !== 'undefined') {
-    ArrayPrototypePush(intrinsicPrototypes,
-                       WebAssembly.Module.prototype,
-                       WebAssembly.Instance.prototype,
-                       WebAssembly.Table.prototype,
-                       WebAssembly.Memory.prototype,
-                       WebAssembly.CompileError.prototype,
-                       WebAssembly.LinkError.prototype,
-                       WebAssembly.RuntimeError.prototype,
-    );
-    ArrayPrototypePush(intrinsics, WebAssembly);
-  }
+  ArrayPrototypePush(intrinsicPrototypes,
+                     WebAssembly.Module.prototype,
+                     WebAssembly.Instance.prototype,
+                     WebAssembly.Table.prototype,
+                     WebAssembly.Memory.prototype,
+                     WebAssembly.CompileError.prototype,
+                     WebAssembly.LinkError.prototype,
+                     WebAssembly.RuntimeError.prototype,
+  );
+  ArrayPrototypePush(intrinsics, WebAssembly);
 
   if (typeof Intl !== 'undefined') {
     ArrayPrototypePush(intrinsicPrototypes,

lib/internal/util.js

@@ -45,15 +45,13 @@ const {
   SymbolPrototypeGetDescription,
   SymbolReplace,
   SymbolSplit,
-  globalThis,
 } = primordials;
 
 const {
   codes: {
     ERR_NO_CRYPTO,
     ERR_NO_TYPESCRIPT,
     ERR_UNKNOWN_SIGNAL,
-    ERR_WEBASSEMBLY_NOT_SUPPORTED,
   },
   isErrorStackTraceLimitWritable,
   overrideStackTrace,
@@ -245,8 +243,6 @@ function assertCrypto() {
 function assertTypeScript() {
   if (noTypeScript)
     throw new ERR_NO_TYPESCRIPT();
-  if (globalThis.WebAssembly === undefined)
-    throw new ERR_WEBASSEMBLY_NOT_SUPPORTED('TypeScript');
 }
 
 /**

src/node_options.cc

@@ -1568,10 +1568,6 @@ PerIsolateOptionsParser::PerIsolateOptionsParser(
             "disallow eval and friends",
             V8Option{},
             kAllowedInEnvvar);
-  AddOption("--jitless",
-            "disable runtime allocation of executable memory",
-            V8Option{},
-            kAllowedInEnvvar);
   AddOption("--report-uncaught-exception",
             "generate diagnostic report on uncaught exceptions",
             BOOL_FIELD(report_uncaught_exception),

test/es-module/test-typescript.mjs

@@ -318,14 +318,3 @@ test('execute invalid TypeScript syntax', async () => {
   assert.strictEqual(result.stdout, '');
   assert.strictEqual(result.code, 1);
 });
-
-test('expect error when executing a TypeScript file with --jitless', async () => {
-  const result = await spawnPromisified(process.execPath, [
-    '--jitless',
-    fixtures.path('typescript/ts/test-typescript.ts'),
-  ]);
-
-  assert.match(result.stderr, /ERR_WEBASSEMBLY_NOT_SUPPORTED/);
-  assert.match(result.stderr, /WebAssembly is not supported in this environment, but is required for TypeScript/);
-  assert.strictEqual(result.code, 1);
-});

test/parallel/test-cli-no-jitless.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+
+// Interpreter-only modes must not bypass Node's WebAssembly requirement,
+// including through V8's alternate flag spellings and runtime flag API.
+for (const flag of [
+  '--jitless', '--lite-mode', '--lite_mode', '-jitless', '-lite_mode',
+  '--jitless=true', '--lite_mode=true', '--no-jitless', '--no-lite-mode',
+]) {
+  const result = spawnSync(process.execPath, [flag, '-e', ''], { encoding: 'utf8' });
+  assert.strictEqual(result.status, 9, result.stderr);
+  assert.strictEqual(result.signal, null);
+  assert.match(result.stderr, /bad option:/);
+
+  const runtime = spawnSync(process.execPath, ['-e', `
+    require('v8').setFlagsFromString(${JSON.stringify(flag)});
+    const bytes = Uint8Array.of(0, 97, 115, 109, 1, 0, 0, 0);
+    new WebAssembly.Instance(new WebAssembly.Module(bytes));
+  `], { encoding: 'utf8' });
+  assert.strictEqual(runtime.status, 0, runtime.stderr);
+  assert.match(runtime.stderr, /unrecognized flag/);
+}
+
+const options = spawnSync(process.execPath, ['--v8-options'], { encoding: 'utf8' });
+assert.strictEqual(options.status, 0, options.stderr);
+assert.doesNotMatch(options.stdout, /--(?:jitless|lite[-_]mode)\b/);
+
+for (const flag of ['--jitless', '--lite-mode', '--lite_mode']) {
+  assert.strictEqual(process.allowedNodeEnvironmentFlags.has(flag), false);
+  if (!process.config.variables.node_without_node_options) {
+    const result = spawnSync(process.execPath, ['-e', ''], {
+      encoding: 'utf8',
+      env: { ...process.env, NODE_OPTIONS: flag },
+    });
+    assert.strictEqual(result.status, 9, result.stderr);
+    assert.match(result.stderr, /is not allowed in NODE_OPTIONS/);
+  }
+}
+
+// Workers must inherit a runtime with working WebAssembly as well.
+const { Worker } = require('worker_threads');
+const worker = new Worker(`
+  const { parentPort } = require('worker_threads');
+  const bytes = Uint8Array.of(0, 97, 115, 109, 1, 0, 0, 0);
+  new WebAssembly.Instance(new WebAssembly.Module(bytes));
+  parentPort.postMessage(typeof WebAssembly);
+`, { eval: true });
+worker.on('message', common.mustCall((value) => assert.strictEqual(value, 'object')));
+worker.on('exit', common.mustCall((code) => assert.strictEqual(code, 0)));

test/parallel/test-cli-node-options.js

@@ -76,7 +76,6 @@ if (common.hasCrypto) {
 expect('--abort_on-uncaught_exception', 'B\n');
 expect('--disallow-code-generation-from-strings', 'B\n');
 expect('--expose-gc', 'B\n');
-expect('--jitless', 'B\n');
 expect('--max-old-space-size=0', 'B\n');
 expect('--max-semi-space-size=0', 'B\n');
 expect('--stack-trace-limit=100',

test/parallel/test-freeze-intrinsics.js

@@ -1,8 +1,11 @@
-// Flags: --frozen-intrinsics --jitless
+// Flags: --frozen-intrinsics
 'use strict';
 require('../common');
 const assert = require('assert');
 
+assert(Object.isFrozen(WebAssembly));
+assert(Object.isFrozen(WebAssembly.Module.prototype));
+
 assert.throws(
   () => Object.defineProperty = 'asdf',
   TypeError

test/parallel/test-internal-webidl-buffer-source.js

@@ -326,9 +326,7 @@ test('Shared buffer growability checks do not read JavaScript properties', () =>
   }
 });
 
-test('Shared WebAssembly buffer growability is checked per buffer', {
-  skip: typeof WebAssembly === 'undefined',
-}, () => {
+test('Shared WebAssembly buffer growability is checked per buffer', () => {
   const memory = new WebAssembly.Memory({ initial: 1, maximum: 2, shared: true });
   for (const [buffer, growable] of [
     [memory.buffer, false],