fixup

Signed-off-by: Paolo Insogna <paolo@cowtech.it>

Author: ShogunPanda

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

@@ -451,13 +451,8 @@ DEFINE_NEG_IMPLICATION(stress_snapshot, incremental_marking)
 #define V8_LITE_MODE_BOOL false
 #endif
 
-// 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
+DEFINE_BOOL(lite_mode, V8_LITE_MODE_BOOL,
+            "enables trade-off of performance for memory savings")
 
 // Lite mode implies other flags to trade-off performance for memory.
 DEFINE_IMPLICATION(lite_mode, jitless)
@@ -942,14 +937,15 @@ DEFINE_STRING(
     "Select which native code sequence to use for wasm trace instruction: "
     "default or cpuid")
 
-#if defined(V8_JITLESS) || defined(V8_LITE_MODE)
-#error Node.js does not support interpreter-only V8 builds.
-#endif
-#define V8_JITLESS_BOOL false
-#if defined(FLAG_MODE_DECLARE)
-DEFINE_BOOL_READONLY(jitless, false,
+#ifdef V8_JITLESS
+#define V8_JITLESS_BOOL true
+DEFINE_BOOL_READONLY(jitless, true,
                      "Disable runtime allocation of executable memory.")
-#endif
+#else
+#define V8_JITLESS_BOOL false
+DEFINE_BOOL(jitless, V8_LITE_MODE_BOOL,
+            "Disable runtime allocation of executable memory.")
+#endif  // V8_JITLESS
 
 // Jitless V8 has a few implications:
 // Field type tracking is only used by TurboFan.

deps/v8/src/flags/flags.cc

@@ -1042,10 +1042,6 @@ 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) \

src/node.cc

@@ -48,6 +48,10 @@
 #include "node_version.h"
 #include "permission/env_permission.h"
 
+#if defined(V8_JITLESS) || defined(V8_LITE_MODE)
+#error Node.js does not support interpreter-only V8 builds.
+#endif
+
 #if HAVE_OPENSSL
 #include "ncrypto.h"
 #if OPENSSL_VERSION_MAJOR >= 3
@@ -1108,6 +1112,12 @@ static ExitCode InitializeNodeWithArgsInternal(
 
   allow_env_sources.Finish();
 
+  // Node.js requires WebAssembly for built-in functionality. Override these
+  // modes after all option sources, before V8 applies their implications.
+  // Explicitly allow overriding even when contradiction checks are enabled.
+  V8::SetFlagsFromString("--allow-overwriting-for-next-flag --no-lite-mode "
+                         "--allow-overwriting-for-next-flag --no-jitless");
+
   // Every option source has now been parsed, so cross-source option
   // constraints can finally be validated.
   CheckGlobalBenchOptions(errors);

src/node_v8.cc

@@ -272,6 +272,10 @@ void SetFlagsFromString(const FunctionCallbackInfo<Value>& args) {
   CHECK(args[0]->IsString());
   Utf8Value flags(args.GetIsolate(), args[0]);
   V8::SetFlagsFromString(flags.out(), flags.length());
+  // Runtime flags must not re-enable modes that disable required WebAssembly
+  // support, even when contradiction checks are enabled.
+  V8::SetFlagsFromString("--allow-overwriting-for-next-flag --no-lite-mode "
+                         "--allow-overwriting-for-next-flag --no-jitless");
 }
 
 void StartCpuProfile(const FunctionCallbackInfo<Value>& args) {

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

@@ -4,29 +4,48 @@ 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.
+// Interpreter-only modes are overridden to preserve Node's WebAssembly
+// requirement, including alternate spellings and the runtime flag API.
+const wasm = `
+  const assert = require('assert');
+  assert.strictEqual(typeof WebAssembly, 'object');
+  const bytes = Uint8Array.of(0, 97, 115, 109, 1, 0, 0, 0);
+  new WebAssembly.Instance(new WebAssembly.Module(bytes));
+`;
+
 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);
+  const result = spawnSync(process.execPath, [flag, '-e', wasm], { encoding: 'utf8' });
+  assert.strictEqual(result.status, 0, result.stderr);
   assert.strictEqual(result.signal, null);
-  assert.match(result.stderr, /bad option:/);
+  assert.strictEqual(result.stderr, '');
 
   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));
+    ${wasm}
+    // A new isolate must also retain WebAssembly after changing runtime flags.
+    new (require('worker_threads').Worker)(${JSON.stringify(wasm)}, { eval: true });
   `], { encoding: 'utf8' });
   assert.strictEqual(runtime.status, 0, runtime.stderr);
-  assert.match(runtime.stderr, /unrecognized flag/);
+  assert.strictEqual(runtime.stderr, '');
+}
+
+// Node's overrides must not be treated as contradictory user-supplied flags.
+for (const flag of ['--jitless', '--lite-mode']) {
+  const result = spawnSync(process.execPath, [
+    '--abort-on-contradictory-flags', flag, '-e', wasm,
+  ], { encoding: 'utf8' });
+  assert.strictEqual(result.status, 0, result.stderr);
+  assert.strictEqual(result.signal, null);
+  assert.strictEqual(result.stderr, '');
 }
 
 const options = spawnSync(process.execPath, ['--v8-options'], { encoding: 'utf8' });
 assert.strictEqual(options.status, 0, options.stderr);
-assert.doesNotMatch(options.stdout, /--(?:jitless|lite[-_]mode)\b/);
+assert.match(options.stdout, /--jitless\b/);
+assert.match(options.stdout, /--lite-mode\b/);
 
 for (const flag of ['--jitless', '--lite-mode', '--lite_mode']) {
   assert.strictEqual(process.allowedNodeEnvironmentFlags.has(flag), false);