Created
February 14, 2023 17:50
-
-
Save cscheid/c293b27d12b921ece35081d2b0b32830 to your computer and use it in GitHub Desktop.
V8 Flags on deno 1.28.2
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| The following syntax for options is accepted (both '-' and '--' are ok): | |
| --flag (bool flags only) | |
| --no-flag (bool flags only) | |
| --flag=value (non-bool flags only, no spaces around '=') | |
| --flag value (non-bool flags only) | |
| -- (captures all remaining args in JavaScript) | |
| Options: | |
| --abort-on-contradictory-flags (Disallow flags or implications overriding each other.) | |
| type: bool default: --no-abort-on-contradictory-flags | |
| --exit-on-contradictory-flags (Exit with return code 0 on contradictory flags.) | |
| type: bool default: --no-exit-on-contradictory-flags | |
| --allow-overwriting-for-next-flag (temporary disable flag contradiction to allow overwriting just the next flag) | |
| type: bool default: --no-allow-overwriting-for-next-flag | |
| --use-strict (enforce strict mode) | |
| type: bool default: --no-use-strict | |
| --trace-temporal (trace temporal code) | |
| type: bool default: --no-trace-temporal | |
| --harmony (enable all completed harmony features) | |
| type: bool default: --no-harmony | |
| --harmony-shipping (enable all shipped harmony features) | |
| type: bool default: --harmony-shipping | |
| --harmony-weak-refs-with-cleanup-some (enable "harmony weak references with FinalizationRegistry.prototype.cleanupSome" (in progress)) | |
| type: bool default: --no-harmony-weak-refs-with-cleanup-some | |
| --harmony-temporal (enable "Temporal" (in progress)) | |
| type: bool default: --no-harmony-temporal | |
| --harmony-shadow-realm (enable "harmony ShadowRealm" (in progress)) | |
| type: bool default: --no-harmony-shadow-realm | |
| --harmony-struct (enable "harmony structs, shared structs, and shared arrays" (in progress)) | |
| type: bool default: --no-harmony-struct | |
| --harmony-regexp-unicode-sets (enable "harmony RegExp Unicode Sets" (in progress)) | |
| type: bool default: --no-harmony-regexp-unicode-sets | |
| --harmony-json-parse-with-source (enable "harmony json parse with source" (in progress)) | |
| type: bool default: --no-harmony-json-parse-with-source | |
| --harmony-intl-best-fit-matcher (enable "Intl BestFitMatcher" (in progress)) | |
| type: bool default: --no-harmony-intl-best-fit-matcher | |
| --harmony-intl-duration-format (enable "Intl DurationFormat API" (in progress)) | |
| type: bool default: --no-harmony-intl-duration-format | |
| --harmony-rab-gsab (enable "harmony ResizableArrayBuffer / GrowableSharedArrayBuffer") | |
| type: bool default: --no-harmony-rab-gsab | |
| --harmony-array-grouping (enable "harmony array grouping") | |
| type: bool default: --no-harmony-array-grouping | |
| --harmony-change-array-by-copy (enable "harmony change-Array-by-copy") | |
| type: bool default: --no-harmony-change-array-by-copy | |
| --harmony-sharedarraybuffer (enable "harmony sharedarraybuffer") | |
| type: bool default: --harmony-sharedarraybuffer | |
| --harmony-atomics (enable "harmony atomics") | |
| type: bool default: --harmony-atomics | |
| --harmony-class-static-blocks (enable "harmony static initializer blocks") | |
| type: bool default: --harmony-class-static-blocks | |
| --harmony-array-find-last (enable "harmony array find last helpers") | |
| type: bool default: --harmony-array-find-last | |
| --harmony-import-assertions (enable "harmony import assertions") | |
| type: bool default: --harmony-import-assertions | |
| --harmony-symbol-as-weakmap-key (enable "harmony symbols as weakmap keys") | |
| type: bool default: --harmony-symbol-as-weakmap-key | |
| --harmony-intl-number-format-v3 (enable "Intl.NumberFormat v3") | |
| type: bool default: --harmony-intl-number-format-v3 | |
| --builtin-subclassing (subclassing support in built-in methods) | |
| type: bool default: --builtin-subclassing | |
| --enable-sharedarraybuffer-per-context (enable the SharedArrayBuffer constructor per context) | |
| type: bool default: --no-enable-sharedarraybuffer-per-context | |
| --icu-timezone-data (get information about timezones from ICU) | |
| type: bool default: --icu-timezone-data | |
| --stress-snapshot (disables sharing of the read-only heap for testing) | |
| type: bool default: --no-stress-snapshot | |
| --lite-mode (enables trade-off of performance for memory savings) | |
| type: bool default: --no-lite-mode | |
| --future (Implies all staged features that we want to ship in the not-too-far future) | |
| type: bool default: --no-future | |
| --lower-tier-as-toptier (remove tier-up logic from the top tier) | |
| type: bool default: --no-lower-tier-as-toptier | |
| --maglev-filter (optimization filter for the maglev compiler) | |
| type: string default: --maglev-filter="*" | |
| --maglev-assert (insert extra assertion in maglev code) | |
| type: bool default: --no-maglev-assert | |
| --maglev-break-on-entry (insert an int3 on maglev entries) | |
| type: bool default: --no-maglev-break-on-entry | |
| --print-maglev-graph (print maglev graph) | |
| type: bool default: --no-print-maglev-graph | |
| --print-maglev-code (print maglev code) | |
| type: bool default: --no-print-maglev-code | |
| --trace-maglev-graph-building (trace maglev graph building) | |
| type: bool default: --no-trace-maglev-graph-building | |
| --trace-maglev-regalloc (trace maglev register allocation) | |
| type: bool default: --no-trace-maglev-regalloc | |
| --maglev-function-context-specialization (enable function context specialization in maglev) | |
| type: bool default: --maglev-function-context-specialization | |
| --maglev-ool-prologue (use the Maglev out of line prologue) | |
| type: bool default: --no-maglev-ool-prologue | |
| --max-opt (Set the maximal optimisation tier: > 3 == any, 0 == ignition/interpreter, 1 == sparkplug/baseline, 2 == maglev, 3 == turbofan) | |
| type: uint default: --max-opt=999 | |
| --wasm-trace-native (Select which native code sequence to use for wasm trace instruction: default or cpuid) | |
| type: string default: --wasm-trace-native="" | |
| --jitless (Disable runtime allocation of executable memory.) | |
| type: bool default: --no-jitless | |
| --assert-types (generate runtime type assertions to test the typer) | |
| type: bool default: --no-assert-types | |
| --verify-simplified-lowering (verify graph generated by simplified lowering) | |
| type: bool default: --no-verify-simplified-lowering | |
| --trace-compilation-dependencies (trace code dependencies) | |
| type: bool default: --no-trace-compilation-dependencies | |
| --allocation-site-pretenuring (pretenure with allocation sites) | |
| type: bool default: --allocation-site-pretenuring | |
| --page-promotion (promote pages based on utilization) | |
| type: bool default: --page-promotion | |
| --page-promotion-threshold (min percentage of live bytes on a page to enable fast evacuation) | |
| type: int default: --page-promotion-threshold=70 | |
| --trace-pretenuring (trace pretenuring decisions of HAllocate instructions) | |
| type: bool default: --no-trace-pretenuring | |
| --trace-pretenuring-statistics (trace allocation site pretenuring statistics) | |
| type: bool default: --no-trace-pretenuring-statistics | |
| --track-field-types (track field types) | |
| type: bool default: --track-field-types | |
| --trace-block-coverage (trace collected block coverage information) | |
| type: bool default: --no-trace-block-coverage | |
| --trace-protector-invalidation (trace protector cell invalidations) | |
| type: bool default: --no-trace-protector-invalidation | |
| --trace-web-snapshot (trace web snapshot deserialization) | |
| type: bool default: --no-trace-web-snapshot | |
| --feedback-normalization (feed back normalization to constructors) | |
| type: bool default: --no-feedback-normalization | |
| --unbox-double-arrays (automatically unbox arrays of doubles) | |
| type: bool default: --unbox-double-arrays | |
| --interrupt-budget-for-feedback-allocation (The fixed interrupt budget (in bytecode size) for allocating feedback vectors) | |
| type: int default: --interrupt-budget-for-feedback-allocation=940 | |
| --interrupt-budget-factor-for-feedback-allocation (The interrupt budget factor (applied to bytecode size) for allocating feedback vectors, used when bytecode size is known) | |
| type: int default: --interrupt-budget-factor-for-feedback-allocation=8 | |
| --interrupt-budget-for-maglev (interrupt budget which should be used for the profiler counter) | |
| type: int default: --interrupt-budget-for-maglev=30720 | |
| --interrupt-budget (interrupt budget which should be used for the profiler counter) | |
| type: int default: --interrupt-budget=67584 | |
| --ticks-before-optimization (the number of times we have to go through the interrupt budget before considering this function for optimization) | |
| type: int default: --ticks-before-optimization=3 | |
| --bytecode-size-allowance-per-tick (increases the number of ticks required for optimization by bytecode.length/X) | |
| type: int default: --bytecode-size-allowance-per-tick=150 | |
| --max-bytecode-size-for-early-opt (Maximum bytecode length for a function to be optimized on the first tick) | |
| type: int default: --max-bytecode-size-for-early-opt=81 | |
| --use-ic (use inline caching) | |
| type: bool default: --use-ic | |
| --lazy-feedback-allocation (Allocate feedback vectors lazily) | |
| type: bool default: --lazy-feedback-allocation | |
| --ignition-elide-noneffectful-bytecodes (elide bytecodes which won't have any external effect) | |
| type: bool default: --ignition-elide-noneffectful-bytecodes | |
| --ignition-reo (use ignition register equivalence optimizer) | |
| type: bool default: --ignition-reo | |
| --ignition-filter-expression-positions (filter expression positions before the bytecode pipeline) | |
| type: bool default: --ignition-filter-expression-positions | |
| --ignition-share-named-property-feedback (share feedback slots when loading the same named property from the same object) | |
| type: bool default: --ignition-share-named-property-feedback | |
| --print-bytecode (print bytecode generated by ignition interpreter) | |
| type: bool default: --no-print-bytecode | |
| --enable-lazy-source-positions (skip generating source positions during initial compile but regenerate when actually required) | |
| type: bool default: --enable-lazy-source-positions | |
| --stress-lazy-source-positions (collect lazy source positions immediately after lazy compile) | |
| type: bool default: --no-stress-lazy-source-positions | |
| --print-bytecode-filter (filter for selecting which functions to print bytecode) | |
| type: string default: --print-bytecode-filter="*" | |
| --omit-default-ctors (omit calling default ctors in bytecode) | |
| type: bool default: --omit-default-ctors | |
| --trace-ignition-codegen (trace the codegen of ignition interpreter bytecode handlers) | |
| type: bool default: --no-trace-ignition-codegen | |
| --trace-ignition-dispatches-output-file (write the bytecode handler dispatch table to the specified file (d8 only) (requires building with v8_enable_ignition_dispatch_counting)) | |
| type: string default: --trace-ignition-dispatches-output-file="" | |
| --trace-track-allocation-sites (trace the tracking of allocation sites) | |
| type: bool default: --no-trace-track-allocation-sites | |
| --trace-migration (trace object migration) | |
| type: bool default: --no-trace-migration | |
| --trace-generalization (trace map generalization) | |
| type: bool default: --no-trace-generalization | |
| --sparkplug (enable Sparkplug baseline compiler) | |
| type: bool default: --sparkplug | |
| --always-sparkplug (directly tier up to Sparkplug code) | |
| type: bool default: --no-always-sparkplug | |
| --baseline-batch-compilation (batch compile Sparkplug code) | |
| type: bool default: --baseline-batch-compilation | |
| --concurrent-sparkplug (compile Sparkplug code in a background thread) | |
| type: bool default: --no-concurrent-sparkplug | |
| --concurrent-sparkplug-max-threads (max number of threads that concurrent Sparkplug can use (0 for unbounded)) | |
| type: uint default: --concurrent-sparkplug-max-threads=0 | |
| --concurrent-sparkplug-high-priority-threads (use high priority compiler threads for concurrent Sparkplug) | |
| type: bool default: --no-concurrent-sparkplug-high-priority-threads | |
| --sparkplug-filter (filter for Sparkplug baseline compiler) | |
| type: string default: --sparkplug-filter="*" | |
| --sparkplug-needs-short-builtins (only enable Sparkplug baseline compiler when --short-builtin-calls are also enabled) | |
| type: bool default: --no-sparkplug-needs-short-builtins | |
| --baseline-batch-compilation-threshold (the estimated instruction size of a batch to trigger compilation) | |
| type: int default: --baseline-batch-compilation-threshold=4096 | |
| --trace-baseline (trace baseline compilation) | |
| type: bool default: --no-trace-baseline | |
| --trace-baseline-batch-compilation (trace baseline batch compilation) | |
| type: bool default: --no-trace-baseline-batch-compilation | |
| --trace-baseline-concurrent-compilation (trace baseline concurrent compilation) | |
| type: bool default: --no-trace-baseline-concurrent-compilation | |
| --shared-string-table (internalize strings into shared table) | |
| type: bool default: --no-shared-string-table | |
| --always-use-string-forwarding-table (use string forwarding table instead of thin strings for all strings) | |
| type: bool default: --no-always-use-string-forwarding-table | |
| --initial-shared-heap-size (initial size of the shared heap (in Mbytes); other heap size flags (e.g. initial_heap_size) take precedence) | |
| type: size_t default: --initial-shared-heap-size=0 | |
| --max-shared-heap-size (max size of the shared heap (in Mbytes); other heap size flags (e.g. max_shared_heap_size) take precedence) | |
| type: size_t default: --max-shared-heap-size=0 | |
| --write-code-using-rwx (flip permissions to rwx to write page instead of rw) | |
| type: bool default: --write-code-using-rwx | |
| --concurrent-recompilation (optimizing hot functions asynchronously on a separate thread) | |
| type: bool default: --concurrent-recompilation | |
| --trace-concurrent-recompilation (track concurrent recompilation) | |
| type: bool default: --no-trace-concurrent-recompilation | |
| --concurrent-recompilation-queue-length (the length of the concurrent compilation queue) | |
| type: int default: --concurrent-recompilation-queue-length=8 | |
| --concurrent-recompilation-delay (artificial compilation delay in ms) | |
| type: int default: --concurrent-recompilation-delay=0 | |
| --stress-concurrent-inlining (create additional concurrent optimization jobs but throw away result) | |
| type: bool default: --no-stress-concurrent-inlining | |
| --maglev-overwrite-budget (whether maglev resets the interrupt budget) | |
| type: bool default: --no-maglev-overwrite-budget | |
| --stress-concurrent-inlining-attach-code (create additional concurrent optimization jobs) | |
| type: bool default: --no-stress-concurrent-inlining-attach-code | |
| --max-serializer-nesting (maximum levels for nesting child serializers) | |
| type: int default: --max-serializer-nesting=25 | |
| --trace-heap-broker-verbose (trace the heap broker verbosely (all reports)) | |
| type: bool default: --no-trace-heap-broker-verbose | |
| --trace-heap-broker-memory (trace the heap broker memory (refs analysis and zone numbers)) | |
| type: bool default: --no-trace-heap-broker-memory | |
| --trace-heap-broker (trace the heap broker (reports on missing data only)) | |
| type: bool default: --no-trace-heap-broker | |
| --stress-runs (number of stress runs) | |
| type: int default: --stress-runs=0 | |
| --deopt-every-n-times (deoptimize every n times a deopt point is passed) | |
| type: int default: --deopt-every-n-times=0 | |
| --print-deopt-stress (print number of possible deopt points) | |
| type: bool default: --no-print-deopt-stress | |
| --turbofan (use the Turbofan optimizing compiler) | |
| type: bool default: --turbofan | |
| --opt (alias for --turbofan) | |
| type: bool default: --opt | |
| --turbo-sp-frame-access (use stack pointer-relative access to frame wherever possible) | |
| type: bool default: --no-turbo-sp-frame-access | |
| --stress-turbo-late-spilling (optimize placement of all spill instructions, not just loop-top phis) | |
| type: bool default: --no-stress-turbo-late-spilling | |
| --turbo-filter (optimization filter for TurboFan compiler) | |
| type: string default: --turbo-filter="*" | |
| --trace-turbo (trace generated TurboFan IR) | |
| type: bool default: --no-trace-turbo | |
| --trace-turbo-path (directory to dump generated TurboFan IR to) | |
| type: string default: --trace-turbo-path="" | |
| --trace-turbo-filter (filter for tracing turbofan compilation) | |
| type: string default: --trace-turbo-filter="*" | |
| --trace-turbo-graph (trace generated TurboFan graphs) | |
| type: bool default: --no-trace-turbo-graph | |
| --trace-turbo-scheduled (trace TurboFan IR with schedule) | |
| type: bool default: --no-trace-turbo-scheduled | |
| --trace-turbo-file-prefix (trace turbo graph to a file with given prefix) | |
| type: string default: --trace-turbo-file-prefix="turbo" | |
| --trace-turbo-cfg-file (trace turbo cfg graph (for C1 visualizer) to a given file name) | |
| type: string default: --trace-turbo-cfg-file="" | |
| --trace-turbo-types (trace TurboFan's types) | |
| type: bool default: --trace-turbo-types | |
| --trace-turbo-scheduler (trace TurboFan's scheduler) | |
| type: bool default: --no-trace-turbo-scheduler | |
| --trace-turbo-reduction (trace TurboFan's various reducers) | |
| type: bool default: --no-trace-turbo-reduction | |
| --trace-turbo-trimming (trace TurboFan's graph trimmer) | |
| type: bool default: --no-trace-turbo-trimming | |
| --trace-turbo-jt (trace TurboFan's jump threading) | |
| type: bool default: --no-trace-turbo-jt | |
| --trace-turbo-ceq (trace TurboFan's control equivalence) | |
| type: bool default: --no-trace-turbo-ceq | |
| --trace-turbo-loop (trace TurboFan's loop optimizations) | |
| type: bool default: --no-trace-turbo-loop | |
| --trace-turbo-alloc (trace TurboFan's register allocator) | |
| type: bool default: --no-trace-turbo-alloc | |
| --trace-all-uses (trace all use positions) | |
| type: bool default: --no-trace-all-uses | |
| --trace-representation (trace representation types) | |
| type: bool default: --no-trace-representation | |
| --trace-turbo-stack-accesses (trace stack load/store counters for optimized code in run-time (x64 only)) | |
| type: bool default: --no-trace-turbo-stack-accesses | |
| --turbo-verify (verify TurboFan graphs at each phase) | |
| type: bool default: --no-turbo-verify | |
| --turbo-verify-machine-graph (verify TurboFan machine graph before instruction selection) | |
| type: string default: --turbo-verify-machine-graph="" | |
| --trace-verify-csa (trace code stubs verification) | |
| type: bool default: --no-trace-verify-csa | |
| --csa-trap-on-node (trigger break point when a node with given id is created in given stub. The format is: StubName,NodeId) | |
| type: string default: --csa-trap-on-node="" | |
| --turbo-stats (print TurboFan statistics) | |
| type: bool default: --no-turbo-stats | |
| --turbo-stats-nvp (print TurboFan statistics in machine-readable format) | |
| type: bool default: --no-turbo-stats-nvp | |
| --turbo-stats-wasm (print TurboFan statistics of wasm compilations) | |
| type: bool default: --no-turbo-stats-wasm | |
| --turbo-splitting (split nodes during scheduling in TurboFan) | |
| type: bool default: --turbo-splitting | |
| --turbo-inlining (enable inlining in TurboFan) | |
| type: bool default: --turbo-inlining | |
| --max-inlined-bytecode-size (maximum size of bytecode for a single inlining) | |
| type: int default: --max-inlined-bytecode-size=460 | |
| --max-inlined-bytecode-size-cumulative (maximum cumulative size of bytecode considered for inlining) | |
| type: int default: --max-inlined-bytecode-size-cumulative=920 | |
| --max-inlined-bytecode-size-absolute (maximum absolute size of bytecode considered for inlining) | |
| type: int default: --max-inlined-bytecode-size-absolute=4600 | |
| --reserve-inline-budget-scale-factor (scale factor of bytecode size used to calculate the inlining budget) | |
| type: float default: --reserve-inline-budget-scale-factor=1.2 | |
| --max-inlined-bytecode-size-small (maximum size of bytecode considered for small function inlining) | |
| type: int default: --max-inlined-bytecode-size-small=27 | |
| --max-optimized-bytecode-size (maximum bytecode size to be considered for optimization; too high values may cause the compiler to hit (release) assertions) | |
| type: int default: --max-optimized-bytecode-size=61440 | |
| --min-inlining-frequency (minimum frequency for inlining) | |
| type: float default: --min-inlining-frequency=0.15 | |
| --polymorphic-inlining (polymorphic inlining) | |
| type: bool default: --polymorphic-inlining | |
| --stress-inline (set high thresholds for inlining to inline as much as possible) | |
| type: bool default: --no-stress-inline | |
| --trace-turbo-inlining (trace TurboFan inlining) | |
| type: bool default: --no-trace-turbo-inlining | |
| --turbo-inline-array-builtins (inline array builtins in TurboFan code) | |
| type: bool default: --turbo-inline-array-builtins | |
| --use-osr (use on-stack replacement) | |
| type: bool default: --use-osr | |
| --concurrent-osr (enable concurrent OSR) | |
| type: bool default: --concurrent-osr | |
| --trace-osr (trace on-stack replacement) | |
| type: bool default: --no-trace-osr | |
| --log-or-trace-osr (internal helper flag, please use --trace-osr instead.) | |
| type: bool default: --no-log-or-trace-osr | |
| --analyze-environment-liveness (analyze liveness of environment slots and zap dead values) | |
| type: bool default: --analyze-environment-liveness | |
| --trace-environment-liveness (trace liveness of local variable slots) | |
| type: bool default: --no-trace-environment-liveness | |
| --turbo-load-elimination (enable load elimination in TurboFan) | |
| type: bool default: --turbo-load-elimination | |
| --trace-turbo-load-elimination (trace TurboFan load elimination) | |
| type: bool default: --no-trace-turbo-load-elimination | |
| --turbo-profiling (enable basic block profiling in TurboFan) | |
| type: bool default: --no-turbo-profiling | |
| --turbo-profiling-verbose (enable basic block profiling in TurboFan, and include each function's schedule and disassembly in the output) | |
| type: bool default: --no-turbo-profiling-verbose | |
| --turbo-profiling-output (emit data about basic block usage in builtins to this file (requires that V8 was built with v8_enable_builtins_profiling=true)) | |
| type: string default: --turbo-profiling-output="" | |
| --warn-about-builtin-profile-data (flag for mksnapshot, emit warnings when applying builtin profile data) | |
| type: bool default: --no-warn-about-builtin-profile-data | |
| --turbo-verify-allocation (verify register allocation in TurboFan) | |
| type: bool default: --no-turbo-verify-allocation | |
| --turbo-move-optimization (optimize gap moves in TurboFan) | |
| type: bool default: --turbo-move-optimization | |
| --turbo-jt (enable jump threading in TurboFan) | |
| type: bool default: --turbo-jt | |
| --turbo-loop-peeling (TurboFan loop peeling) | |
| type: bool default: --turbo-loop-peeling | |
| --turbo-loop-variable (TurboFan loop variable optimization) | |
| type: bool default: --turbo-loop-variable | |
| --turbo-loop-rotation (TurboFan loop rotation) | |
| type: bool default: --turbo-loop-rotation | |
| --turbo-cf-optimization (optimize control flow in TurboFan) | |
| type: bool default: --turbo-cf-optimization | |
| --turbo-escape (enable escape analysis) | |
| type: bool default: --turbo-escape | |
| --turbo-allocation-folding (TurboFan allocation folding) | |
| type: bool default: --turbo-allocation-folding | |
| --turbo-instruction-scheduling (enable instruction scheduling in TurboFan) | |
| type: bool default: --no-turbo-instruction-scheduling | |
| --turbo-stress-instruction-scheduling (randomly schedule instructions to stress dependency tracking) | |
| type: bool default: --no-turbo-stress-instruction-scheduling | |
| --turbo-store-elimination (enable store-store elimination in TurboFan) | |
| type: bool default: --turbo-store-elimination | |
| --trace-store-elimination (trace store elimination) | |
| type: bool default: --no-trace-store-elimination | |
| --turbo-rab-gsab (optimize ResizableArrayBuffer / GrowableSharedArrayBuffer in TurboFan) | |
| type: bool default: --turbo-rab-gsab | |
| --stress-gc-during-compilation (simulate GC/compiler thread race related to https://crbug.com/v8/8520) | |
| type: bool default: --no-stress-gc-during-compilation | |
| --turbo-fast-api-calls (enable fast API calls from TurboFan) | |
| type: bool default: --turbo-fast-api-calls | |
| --turbo-compress-translation-arrays (compress translation arrays (experimental)) | |
| type: bool default: --no-turbo-compress-translation-arrays | |
| --turbo-inline-js-wasm-calls (inline JS->Wasm calls) | |
| type: bool default: --turbo-inline-js-wasm-calls | |
| --turbo-use-mid-tier-regalloc-for-huge-functions (fall back to the mid-tier register allocator for huge functions) | |
| type: bool default: --turbo-use-mid-tier-regalloc-for-huge-functions | |
| --turbo-force-mid-tier-regalloc (always use the mid-tier register allocator (for testing)) | |
| type: bool default: --no-turbo-force-mid-tier-regalloc | |
| --turbo-optimize-apply (optimize Function.prototype.apply) | |
| type: bool default: --turbo-optimize-apply | |
| --turbo-optimize-math-minmax (optimize call math.min/max with double array) | |
| type: bool default: --turbo-optimize-math-minmax | |
| --turbo-collect-feedback-in-generic-lowering (enable experimental feedback collection in generic lowering.) | |
| type: bool default: --turbo-collect-feedback-in-generic-lowering | |
| --isolate-script-cache-ageing (enable ageing of the isolate script cache.) | |
| type: bool default: --isolate-script-cache-ageing | |
| --script-delay (busy wait [ms] on every Script::Run) | |
| type: float default: --script-delay=0 | |
| --script-delay-once (busy wait [ms] on the first Script::Run) | |
| type: float default: --script-delay-once=0 | |
| --script-delay-fraction (busy wait after each Script::Run by the given fraction of the run's duration) | |
| type: float default: --script-delay-fraction=0 | |
| --turboshaft (enable TurboFan's Turboshaft phases for JS) | |
| type: bool default: --no-turboshaft | |
| --turboshaft-trace-reduction (trace individual Turboshaft reduction steps) | |
| type: bool default: --no-turboshaft-trace-reduction | |
| --turboshaft-wasm (enable TurboFan's Turboshaft phases for wasm) | |
| type: bool default: --no-turboshaft-wasm | |
| --optimize-for-size (Enables optimizations which favor memory size over execution speed) | |
| type: bool default: --no-optimize-for-size | |
| --wasm-generic-wrapper (allow use of the generic js-to-wasm wrapper instead of per-signature wrappers) | |
| type: bool default: --wasm-generic-wrapper | |
| --enable-wasm-arm64-generic-wrapper (allow use of the generic js-to-wasm wrapper instead of per-signature wrappers on arm64) | |
| type: bool default: --enable-wasm-arm64-generic-wrapper | |
| --expose-wasm (expose wasm interface to JavaScript) | |
| type: bool default: --expose-wasm | |
| --wasm-num-compilation-tasks (maximum number of parallel compilation tasks for wasm) | |
| type: int default: --wasm-num-compilation-tasks=128 | |
| --wasm-write-protect-code-memory (write protect code memory on the wasm native heap with mprotect) | |
| type: bool default: --wasm-write-protect-code-memory | |
| --wasm-memory-protection-keys (protect wasm code memory with PKU if available (takes precedence over --wasm-write-protect-code-memory)) | |
| type: bool default: --wasm-memory-protection-keys | |
| --wasm-async-compilation (enable actual asynchronous compilation for WebAssembly.compile) | |
| type: bool default: --wasm-async-compilation | |
| --wasm-test-streaming (use streaming compilation instead of async compilation for tests) | |
| type: bool default: --no-wasm-test-streaming | |
| --wasm-native-module-cache-enabled (enable the native module cache) | |
| type: bool default: --wasm-native-module-cache-enabled | |
| --wasm-max-mem-pages (maximum number of 64KiB memory pages per wasm memory) | |
| type: uint default: --wasm-max-mem-pages=4294967295 | |
| --wasm-max-table-size (maximum table size of a wasm instance) | |
| type: uint default: --wasm-max-table-size=10000000 | |
| --wasm-max-code-space (maximum committed code space for wasm (in MB)) | |
| type: uint default: --wasm-max-code-space=4095 | |
| --wasm-tier-up (enable tier up to the optimizing compiler (requires --liftoff to have an effect)) | |
| type: bool default: --wasm-tier-up | |
| --wasm-dynamic-tiering (enable dynamic tier up to the optimizing compiler) | |
| type: bool default: --wasm-dynamic-tiering | |
| --wasm-tiering-budget (budget for dynamic tiering (rough approximation of bytes executed) | |
| type: int default: --wasm-tiering-budget=1800000 | |
| --wasm-caching-threshold (the amount of wasm top tier code that triggers the next caching event) | |
| type: int default: --wasm-caching-threshold=1000000 | |
| --trace-wasm-compilation-times (print how long it took to compile each wasm function) | |
| type: bool default: --no-trace-wasm-compilation-times | |
| --wasm-tier-up-filter (only tier-up function with this index) | |
| type: int default: --wasm-tier-up-filter=-1 | |
| --wasm-stack-switching-stack-size (default size of stacks for wasm stack-switching (in kB)) | |
| type: int default: --wasm-stack-switching-stack-size=864 | |
| --liftoff (enable Liftoff, the baseline compiler for WebAssembly) | |
| type: bool default: --liftoff | |
| --liftoff-only (disallow TurboFan compilation for WebAssembly (for testing)) | |
| type: bool default: --no-liftoff-only | |
| --trace-wasm-memory (print all memory updates performed in wasm code) | |
| type: bool default: --no-trace-wasm-memory | |
| --wasm-tier-mask-for-testing (bitmask of functions to compile with TurboFan instead of Liftoff) | |
| type: int default: --wasm-tier-mask-for-testing=0 | |
| --wasm-debug-mask-for-testing (bitmask of functions to compile for debugging, only applies if the tier is Liftoff) | |
| type: int default: --wasm-debug-mask-for-testing=0 | |
| --experimental-wasm-pgo-to-file (experimental: dump Wasm PGO information to a local file (for testing)) | |
| type: bool default: --no-experimental-wasm-pgo-to-file | |
| --experimental-wasm-pgo-from-file (experimental: read and use Wasm PGO data from a local file (for testing)) | |
| type: bool default: --no-experimental-wasm-pgo-from-file | |
| --validate-asm (validate asm.js modules before compiling) | |
| type: bool default: --validate-asm | |
| --suppress-asm-messages (don't emit asm.js related messages (for golden file testing)) | |
| type: bool default: --no-suppress-asm-messages | |
| --trace-asm-time (print asm.js timing info to the console) | |
| type: bool default: --no-trace-asm-time | |
| --trace-asm-scanner (print tokens encountered by asm.js scanner) | |
| type: bool default: --no-trace-asm-scanner | |
| --trace-asm-parser (verbose logging of asm.js parse failures) | |
| type: bool default: --no-trace-asm-parser | |
| --stress-validate-asm (try to validate everything as asm.js) | |
| type: bool default: --no-stress-validate-asm | |
| --dump-wasm-module-path (directory to dump wasm modules to) | |
| type: string default: --dump-wasm-module-path="" | |
| --experimental-wasm-compilation-hints (enable prototype compilation hints section for wasm) | |
| type: bool default: --no-experimental-wasm-compilation-hints | |
| --experimental-wasm-instruction-tracing (enable prototype instruction tracing section for wasm) | |
| type: bool default: --no-experimental-wasm-instruction-tracing | |
| --experimental-wasm-gc (enable prototype garbage collection for wasm) | |
| type: bool default: --no-experimental-wasm-gc | |
| --experimental-wasm-assume-ref-cast-succeeds (enable prototype assume ref.cast always succeeds and skip the related type check (unsafe) for wasm) | |
| type: bool default: --no-experimental-wasm-assume-ref-cast-succeeds | |
| --experimental-wasm-ref-cast-nop (enable prototype enable unsafe ref.cast_nop instruction for wasm) | |
| type: bool default: --no-experimental-wasm-ref-cast-nop | |
| --experimental-wasm-skip-null-checks (enable prototype skip null checks for call.ref and array and struct operations (unsafe) for wasm) | |
| type: bool default: --no-experimental-wasm-skip-null-checks | |
| --experimental-wasm-skip-bounds-checks (enable prototype skip array bounds checks (unsafe) for wasm) | |
| type: bool default: --no-experimental-wasm-skip-bounds-checks | |
| --experimental-wasm-typed-funcref (enable prototype typed function references for wasm) | |
| type: bool default: --no-experimental-wasm-typed-funcref | |
| --experimental-wasm-memory64 (enable prototype memory64 for wasm) | |
| type: bool default: --no-experimental-wasm-memory64 | |
| --experimental-wasm-relaxed-simd (enable prototype relaxed simd for wasm) | |
| type: bool default: --no-experimental-wasm-relaxed-simd | |
| --experimental-wasm-branch-hinting (enable prototype branch hinting for wasm) | |
| type: bool default: --no-experimental-wasm-branch-hinting | |
| --experimental-wasm-stack-switching (enable prototype stack switching for wasm) | |
| type: bool default: --no-experimental-wasm-stack-switching | |
| --experimental-wasm-extended-const (enable prototype extended constant expressions for wasm) | |
| type: bool default: --no-experimental-wasm-extended-const | |
| --experimental-wasm-stringref (enable prototype reference-typed strings for wasm) | |
| type: bool default: --no-experimental-wasm-stringref | |
| --experimental-wasm-return-call (enable prototype return call opcodes for wasm) | |
| type: bool default: --no-experimental-wasm-return-call | |
| --experimental-wasm-type-reflection (enable prototype wasm type reflection in JS for wasm) | |
| type: bool default: --no-experimental-wasm-type-reflection | |
| --wasm-gc-structref-as-dataref (compatibility mode: Treat structref as dataref) | |
| type: bool default: --wasm-gc-structref-as-dataref | |
| --wasm-staging (enable staged wasm features) | |
| type: bool default: --no-wasm-staging | |
| --wasm-opt (enable wasm optimization) | |
| type: bool default: --wasm-opt | |
| --wasm-bounds-checks (enable bounds checks (disable for performance testing only)) | |
| type: bool default: --wasm-bounds-checks | |
| --wasm-stack-checks (enable stack checks (disable for performance testing only)) | |
| type: bool default: --wasm-stack-checks | |
| --wasm-enforce-bounds-checks (enforce explicit bounds check even if the trap handler is available) | |
| type: bool default: --no-wasm-enforce-bounds-checks | |
| --wasm-math-intrinsics (intrinsify some Math imports into wasm) | |
| type: bool default: --wasm-math-intrinsics | |
| --wasm-inlining (enable inlining of wasm functions into wasm functions (experimental)) | |
| type: bool default: --no-wasm-inlining | |
| --wasm-inlining-budget (maximum graph size (in TF nodes) that allows inlining more) | |
| type: size_t default: --wasm-inlining-budget=9000 | |
| --wasm-speculative-inlining (enable speculative inlining of call_ref targets (experimental)) | |
| type: bool default: --no-wasm-speculative-inlining | |
| --trace-wasm-inlining (trace wasm inlining) | |
| type: bool default: --no-trace-wasm-inlining | |
| --trace-wasm-speculative-inlining (trace wasm speculative inlining) | |
| type: bool default: --no-trace-wasm-speculative-inlining | |
| --trace-wasm-typer (trace wasm typer) | |
| type: bool default: --no-trace-wasm-typer | |
| --wasm-loop-unrolling (enable loop unrolling for wasm functions) | |
| type: bool default: --wasm-loop-unrolling | |
| --wasm-loop-peeling (enable loop peeling for wasm functions) | |
| type: bool default: --no-wasm-loop-peeling | |
| --wasm-loop-peeling-max-size (maximum size for peeling) | |
| type: size_t default: --wasm-loop-peeling-max-size=1000 | |
| --wasm-fuzzer-gen-test (generate a test case when running a wasm fuzzer) | |
| type: bool default: --no-wasm-fuzzer-gen-test | |
| --print-wasm-code (print WebAssembly code) | |
| type: bool default: --no-print-wasm-code | |
| --print-wasm-code-function-index (print WebAssembly code for function at index) | |
| type: int default: --print-wasm-code-function-index=-1 | |
| --print-wasm-stub-code (print WebAssembly stub code) | |
| type: bool default: --no-print-wasm-stub-code | |
| --asm-wasm-lazy-compilation (enable lazy compilation for asm-wasm modules) | |
| type: bool default: --no-asm-wasm-lazy-compilation | |
| --wasm-lazy-compilation (enable lazy compilation for all wasm modules) | |
| type: bool default: --no-wasm-lazy-compilation | |
| --wasm-lazy-validation (enable lazy validation for lazily compiled wasm functions) | |
| type: bool default: --no-wasm-lazy-validation | |
| --wasm-simd-ssse3-codegen (allow wasm SIMD SSSE3 codegen) | |
| type: bool default: --no-wasm-simd-ssse3-codegen | |
| --wasm-code-gc (enable garbage collection of wasm code) | |
| type: bool default: --wasm-code-gc | |
| --trace-wasm-code-gc (trace garbage collection of wasm code) | |
| type: bool default: --no-trace-wasm-code-gc | |
| --stress-wasm-code-gc (stress test garbage collection of wasm code) | |
| type: bool default: --no-stress-wasm-code-gc | |
| --wasm-max-initial-code-space-reservation (maximum size of the initial wasm code space reservation (in MB)) | |
| type: int default: --wasm-max-initial-code-space-reservation=0 | |
| --wasm-max-module-size (maximum allowed size of wasm modules) | |
| type: size_t default: --wasm-max-module-size=1073741824 | |
| --wasm-disassembly-max-mb (maximum size of produced disassembly (in MB, approximate)) | |
| type: size_t default: --wasm-disassembly-max-mb=1000 | |
| --trace-wasm (trace wasm function calls) | |
| type: bool default: --no-trace-wasm | |
| --stress-sampling-allocation-profiler (Enables sampling allocation profiler with X as a sample interval) | |
| type: int default: --stress-sampling-allocation-profiler=0 | |
| --lazy-new-space-shrinking (Enables the lazy new space shrinking strategy) | |
| type: bool default: --no-lazy-new-space-shrinking | |
| --min-semi-space-size (min size of a semi-space (in MBytes), the new space consists of two semi-spaces) | |
| type: size_t default: --min-semi-space-size=0 | |
| --max-semi-space-size (max size of a semi-space (in MBytes), the new space consists of two semi-spaces) | |
| type: size_t default: --max-semi-space-size=0 | |
| --semi-space-growth-factor (factor by which to grow the new space) | |
| type: int default: --semi-space-growth-factor=2 | |
| --max-old-space-size (max size of the old space (in Mbytes)) | |
| type: size_t default: --max-old-space-size=0 | |
| --max-heap-size (max size of the heap (in Mbytes) both max_semi_space_size and max_old_space_size take precedence. All three flags cannot be specified at the same time.) | |
| type: size_t default: --max-heap-size=0 | |
| --initial-heap-size (initial size of the heap (in Mbytes)) | |
| type: size_t default: --initial-heap-size=0 | |
| --huge-max-old-generation-size (Increase max size of the old space to 4 GB for x64 systems withthe physical memory bigger than 16 GB) | |
| type: bool default: --huge-max-old-generation-size | |
| --initial-old-space-size (initial old space size (in Mbytes)) | |
| type: size_t default: --initial-old-space-size=0 | |
| --separate-gc-phases (young and full garbage collection phases are not overlapping) | |
| type: bool default: --no-separate-gc-phases | |
| --global-gc-scheduling (enable GC scheduling based on global memory) | |
| type: bool default: --global-gc-scheduling | |
| --gc-global (always perform global GCs) | |
| type: bool default: --no-gc-global | |
| --shared-space (Implement shared heap as shared space on a main isolate.) | |
| type: bool default: --no-shared-space | |
| --random-gc-interval (Collect garbage after random(0, X) allocations. It overrides gc_interval.) | |
| type: int default: --random-gc-interval=0 | |
| --gc-interval (garbage collect after <n> allocations) | |
| type: int default: --gc-interval=-1 | |
| --retain-maps-for-n-gc (keeps maps alive for <n> old space garbage collections) | |
| type: int default: --retain-maps-for-n-gc=2 | |
| --trace-gc (print one trace line following each garbage collection) | |
| type: bool default: --no-trace-gc | |
| --trace-gc-nvp (print one detailed trace line in name=value format after each garbage collection) | |
| type: bool default: --no-trace-gc-nvp | |
| --trace-gc-ignore-scavenger (do not print trace line after scavenger collection) | |
| type: bool default: --no-trace-gc-ignore-scavenger | |
| --trace-idle-notification (print one trace line following each idle notification) | |
| type: bool default: --no-trace-idle-notification | |
| --trace-idle-notification-verbose (prints the heap state used by the idle notification) | |
| type: bool default: --no-trace-idle-notification-verbose | |
| --trace-gc-verbose (print more details following each garbage collection) | |
| type: bool default: --no-trace-gc-verbose | |
| --trace-gc-freelists (prints details of each freelist before and after each major garbage collection) | |
| type: bool default: --no-trace-gc-freelists | |
| --trace-gc-freelists-verbose (prints details of freelists of each page before and after each major garbage collection) | |
| type: bool default: --no-trace-gc-freelists-verbose | |
| --trace-gc-heap-layout (print layout of pages in heap before and after gc) | |
| type: bool default: --no-trace-gc-heap-layout | |
| --trace-gc-heap-layout-ignore-minor-gc (do not print trace line before and after minor-gc) | |
| type: bool default: --trace-gc-heap-layout-ignore-minor-gc | |
| --trace-evacuation-candidates (Show statistics about the pages evacuation by the compaction) | |
| type: bool default: --no-trace-evacuation-candidates | |
| --trace-allocations-origins (Show statistics about the origins of allocations. Combine with --no-inline-new to track allocations from generated code) | |
| type: bool default: --no-trace-allocations-origins | |
| --trace-pending-allocations (trace calls to Heap::IsAllocationPending that return true) | |
| type: bool default: --no-trace-pending-allocations | |
| --trace-allocation-stack-interval (print stack trace after <n> free-list allocations) | |
| type: int default: --trace-allocation-stack-interval=-1 | |
| --trace-duplicate-threshold-kb (print duplicate objects in the heap if their size is more than given threshold) | |
| type: int default: --trace-duplicate-threshold-kb=0 | |
| --trace-fragmentation (report fragmentation for old space) | |
| type: bool default: --no-trace-fragmentation | |
| --trace-fragmentation-verbose (report fragmentation for old space (detailed)) | |
| type: bool default: --no-trace-fragmentation-verbose | |
| --minor-mc-trace-fragmentation (trace fragmentation after marking) | |
| type: bool default: --no-minor-mc-trace-fragmentation | |
| --trace-evacuation (report evacuation statistics) | |
| type: bool default: --no-trace-evacuation | |
| --trace-mutator-utilization (print mutator utilization, allocation speed, gc speed) | |
| type: bool default: --no-trace-mutator-utilization | |
| --incremental-marking (use incremental marking) | |
| type: bool default: --incremental-marking | |
| --incremental-marking-wrappers (use incremental marking for marking wrappers) | |
| type: bool default: --incremental-marking-wrappers | |
| --incremental-marking-task (use tasks for incremental marking) | |
| type: bool default: --incremental-marking-task | |
| --incremental-marking-soft-trigger (threshold for starting incremental marking via a task in percent of available space: limit - size) | |
| type: int default: --incremental-marking-soft-trigger=0 | |
| --fast-forward-schedule (Fast forwards marking schedule) | |
| type: bool default: --no-fast-forward-schedule | |
| --incremental-marking-hard-trigger (threshold for starting incremental marking immediately in percent of available space: limit - size) | |
| type: int default: --incremental-marking-hard-trigger=0 | |
| --trace-unmapper (Trace the unmapping) | |
| type: bool default: --no-trace-unmapper | |
| --minor-mc-task-trigger (minormc task trigger in percent of the current heap limit) | |
| type: int default: --minor-mc-task-trigger=80 | |
| --parallel-scavenge (parallel scavenge) | |
| type: bool default: --parallel-scavenge | |
| --scavenge-task (schedule scavenge tasks) | |
| type: bool default: --scavenge-task | |
| --scavenge-task-trigger (scavenge task trigger in percent of the current heap limit) | |
| type: int default: --scavenge-task-trigger=80 | |
| --scavenge-separate-stack-scanning (use a separate phase for stack scanning in scavenge) | |
| type: bool default: --no-scavenge-separate-stack-scanning | |
| --trace-parallel-scavenge (trace parallel scavenge) | |
| type: bool default: --no-trace-parallel-scavenge | |
| --cppgc-young-generation (run young generation garbage collections in Oilpan) | |
| type: bool default: --no-cppgc-young-generation | |
| --write-protect-code-memory (write protect code memory) | |
| type: bool default: --write-protect-code-memory | |
| --concurrent-marking (use concurrent marking) | |
| type: bool default: --concurrent-marking | |
| --concurrent-marking-max-worker-num (max worker number of concurrent marking, 0 for NumberOfWorkerThreads) | |
| type: int default: --concurrent-marking-max-worker-num=7 | |
| --concurrent-array-buffer-sweeping (concurrently sweep array buffers) | |
| type: bool default: --concurrent-array-buffer-sweeping | |
| --stress-concurrent-allocation (start background threads that allocate memory) | |
| type: bool default: --no-stress-concurrent-allocation | |
| --parallel-marking (use parallel marking in atomic pause) | |
| type: bool default: --parallel-marking | |
| --ephemeron-fixpoint-iterations (number of fixpoint iterations it takes to switch to linear ephemeron algorithm) | |
| type: int default: --ephemeron-fixpoint-iterations=10 | |
| --trace-concurrent-marking (trace concurrent marking) | |
| type: bool default: --no-trace-concurrent-marking | |
| --concurrent-sweeping (use concurrent sweeping) | |
| type: bool default: --concurrent-sweeping | |
| --parallel-compaction (use parallel compaction) | |
| type: bool default: --parallel-compaction | |
| --parallel-pointer-update (use parallel pointer update during compaction) | |
| type: bool default: --parallel-pointer-update | |
| --detect-ineffective-gcs-near-heap-limit (trigger out-of-memory failure to avoid GC storm near heap limit) | |
| type: bool default: --detect-ineffective-gcs-near-heap-limit | |
| --trace-incremental-marking (trace progress of the incremental marking) | |
| type: bool default: --no-trace-incremental-marking | |
| --trace-stress-marking (trace stress marking progress) | |
| type: bool default: --no-trace-stress-marking | |
| --trace-stress-scavenge (trace stress scavenge progress) | |
| type: bool default: --no-trace-stress-scavenge | |
| --track-gc-object-stats (track object counts and memory usage) | |
| type: bool default: --no-track-gc-object-stats | |
| --trace-gc-object-stats (trace object counts and memory usage) | |
| type: bool default: --no-trace-gc-object-stats | |
| --trace-zone-stats (trace zone memory usage) | |
| type: bool default: --no-trace-zone-stats | |
| --zone-stats-tolerance (report a tick only when allocated zone memory changes by this amount) | |
| type: size_t default: --zone-stats-tolerance=1048576 | |
| --trace-zone-type-stats (trace per-type zone memory usage) | |
| type: bool default: --no-trace-zone-type-stats | |
| --track-retaining-path (enable support for tracking retaining path) | |
| type: bool default: --no-track-retaining-path | |
| --gc-stats (Used by tracing internally to enable gc statistics) | |
| type: int default: --gc-stats=0 | |
| --track-detached-contexts (track native contexts that are expected to be garbage collected) | |
| type: bool default: --track-detached-contexts | |
| --trace-detached-contexts (trace native contexts that are expected to be garbage collected) | |
| type: bool default: --no-trace-detached-contexts | |
| --move-object-start (enable moving of object starts) | |
| type: bool default: --move-object-start | |
| --memory-reducer (use memory reducer) | |
| type: bool default: --memory-reducer | |
| --memory-reducer-for-small-heaps (use memory reducer for small heaps) | |
| type: bool default: --memory-reducer-for-small-heaps | |
| --heap-growing-percent (specifies heap growing factor as (1 + heap_growing_percent/100)) | |
| type: int default: --heap-growing-percent=0 | |
| --v8-os-page-size (override OS page size (in KBytes)) | |
| type: int default: --v8-os-page-size=0 | |
| --allocation-buffer-parking (allocation buffer parking) | |
| type: bool default: --allocation-buffer-parking | |
| --compact (Perform compaction on full GCs based on V8's default heuristics) | |
| type: bool default: --compact | |
| --compact-code-space (Perform code space compaction on full collections.) | |
| type: bool default: --compact-code-space | |
| --compact-on-every-full-gc (Perform compaction on every full GC) | |
| type: bool default: --no-compact-on-every-full-gc | |
| --compact-with-stack (Perform compaction when finalizing a full GC with stack) | |
| type: bool default: --compact-with-stack | |
| --compact-code-space-with-stack (Perform code space compaction when finalizing a full GC with stack) | |
| type: bool default: --compact-code-space-with-stack | |
| --stress-compaction (Stress GC compaction to flush out bugs (implies --force_marking_deque_overflows)) | |
| type: bool default: --no-stress-compaction | |
| --stress-compaction-random (Stress GC compaction by selecting random percent of pages as evacuation candidates. Overrides stress_compaction.) | |
| type: bool default: --no-stress-compaction-random | |
| --flush-baseline-code (flush of baseline code when it has not been executed recently) | |
| type: bool default: --no-flush-baseline-code | |
| --flush-bytecode (flush of bytecode when it has not been executed recently) | |
| type: bool default: --flush-bytecode | |
| --bytecode-old-age (number of gcs before we flush code) | |
| type: int default: --bytecode-old-age=5 | |
| --stress-flush-code (stress code flushing) | |
| type: bool default: --no-stress-flush-code | |
| --trace-flush-bytecode (trace bytecode flushing) | |
| type: bool default: --no-trace-flush-bytecode | |
| --use-marking-progress-bar (Use a progress bar to scan large objects in increments when incremental marking is active.) | |
| type: bool default: --use-marking-progress-bar | |
| --stress-per-context-marking-worklist (Use per-context worklist for marking) | |
| type: bool default: --no-stress-per-context-marking-worklist | |
| --force-marking-deque-overflows (force overflows of marking deque by reducing it's size to 64 words) | |
| type: bool default: --no-force-marking-deque-overflows | |
| --stress-incremental-marking (force incremental marking for small heaps and run it more often) | |
| type: bool default: --no-stress-incremental-marking | |
| --fuzzer-gc-analysis (prints number of allocations and enables analysis mode for gc fuzz testing, e.g. --stress-marking, --stress-scavenge) | |
| type: bool default: --no-fuzzer-gc-analysis | |
| --stress-marking (force marking at random points between 0 and X (inclusive) percent of the regular marking start limit) | |
| type: int default: --stress-marking=0 | |
| --stress-scavenge (force scavenge at random points between 0 and X (inclusive) percent of the new space capacity) | |
| type: int default: --stress-scavenge=0 | |
| --reclaim-unmodified-wrappers (reclaim otherwise unreachable unmodified wrapper objects when possible) | |
| type: bool default: --reclaim-unmodified-wrappers | |
| --gc-experiment-less-compaction (less compaction in non-memory reducing mode) | |
| type: bool default: --no-gc-experiment-less-compaction | |
| --gc-memory-reducer-start-delay-ms (Delay before memory reducer start) | |
| type: int default: --gc-memory-reducer-start-delay-ms=8000 | |
| --disable-abortjs (disables AbortJS runtime function) | |
| type: bool default: --no-disable-abortjs | |
| --randomize-all-allocations (randomize virtual memory reservations by ignoring any hints passed when allocating pages) | |
| type: bool default: --no-randomize-all-allocations | |
| --manual-evacuation-candidates-selection (Test mode only flag. It allows an unit test to select evacuation candidates pages (requires --stress_compaction).) | |
| type: bool default: --no-manual-evacuation-candidates-selection | |
| --clear-free-memory (initialize free memory with 0) | |
| type: bool default: --no-clear-free-memory | |
| --crash-on-aborted-evacuation (crash when evacuation of page fails) | |
| type: bool default: --no-crash-on-aborted-evacuation | |
| --cppheap-incremental-marking (use incremental marking for CppHeap) | |
| type: bool default: --no-cppheap-incremental-marking | |
| --cppheap-concurrent-marking (use concurrent marking for CppHeap) | |
| type: bool default: --no-cppheap-concurrent-marking | |
| --enable-sse3 (enable use of SSE3 instructions if available) | |
| type: bool default: --enable-sse3 | |
| --enable-ssse3 (enable use of SSSE3 instructions if available) | |
| type: bool default: --enable-ssse3 | |
| --enable-sse4-1 (enable use of SSE4.1 instructions if available) | |
| type: bool default: --enable-sse4-1 | |
| --enable-sse4-2 (enable use of SSE4.2 instructions if available) | |
| type: bool default: --enable-sse4-2 | |
| --enable-sahf (enable use of SAHF instruction if available (X64 only)) | |
| type: bool default: --enable-sahf | |
| --enable-avx (enable use of AVX instructions if available) | |
| type: bool default: --enable-avx | |
| --enable-avx2 (enable use of AVX2 instructions if available) | |
| type: bool default: --enable-avx2 | |
| --enable-fma3 (enable use of FMA3 instructions if available) | |
| type: bool default: --enable-fma3 | |
| --enable-bmi1 (enable use of BMI1 instructions if available) | |
| type: bool default: --enable-bmi1 | |
| --enable-bmi2 (enable use of BMI2 instructions if available) | |
| type: bool default: --enable-bmi2 | |
| --enable-lzcnt (enable use of LZCNT instruction if available) | |
| type: bool default: --enable-lzcnt | |
| --enable-popcnt (enable use of POPCNT instruction if available) | |
| type: bool default: --enable-popcnt | |
| --arm-arch (generate instructions for the selected ARM architecture if available: armv6, armv7, armv7+sudiv or armv8) | |
| type: string default: --arm-arch="armv8" | |
| --force-long-branches (force all emitted branches to be in long mode (MIPS/PPC only)) | |
| type: bool default: --no-force-long-branches | |
| --mcpu (enable optimization for specific cpu) | |
| type: string default: --mcpu="auto" | |
| --partial-constant-pool (enable use of partial constant pools (X64 only)) | |
| type: bool default: --partial-constant-pool | |
| --sim-arm64-optional-features (enable optional features on the simulator for testing: none or all) | |
| type: string default: --sim-arm64-optional-features="none" | |
| --enable-source-at-csa-bind (Include source information in the binary at CSA bind locations.) | |
| type: bool default: --no-enable-source-at-csa-bind | |
| --enable-armv7 (deprecated (use --arm_arch instead)) | |
| type: maybe_bool default: --enable-armv7=unset | |
| --enable-vfp3 (deprecated (use --arm_arch instead)) | |
| type: maybe_bool default: --enable-vfp3=unset | |
| --enable-32dregs (deprecated (use --arm_arch instead)) | |
| type: maybe_bool default: --enable-32dregs=unset | |
| --enable-neon (deprecated (use --arm_arch instead)) | |
| type: maybe_bool default: --enable-neon=unset | |
| --enable-sudiv (deprecated (use --arm_arch instead)) | |
| type: maybe_bool default: --enable-sudiv=unset | |
| --enable-armv8 (deprecated (use --arm_arch instead)) | |
| type: maybe_bool default: --enable-armv8=unset | |
| --enable-regexp-unaligned-accesses (enable unaligned accesses for the regexp engine) | |
| type: bool default: --enable-regexp-unaligned-accesses | |
| --script-streaming (enable parsing on background) | |
| type: bool default: --script-streaming | |
| --stress-background-compile (stress test parsing on background) | |
| type: bool default: --no-stress-background-compile | |
| --concurrent-cache-deserialization (enable deserializing code caches on background) | |
| type: bool default: --concurrent-cache-deserialization | |
| --merge-background-deserialized-script-with-compilation-cache (After deserializing code cache data on a background thread, merge it into an existing Script if one is found in the Isolate compilation cache) | |
| type: bool default: --merge-background-deserialized-script-with-compilation-cache | |
| --disable-old-api-accessors (Disable old-style API accessors whose setters trigger through the prototype chain) | |
| type: bool default: --no-disable-old-api-accessors | |
| --embedder-instance-types (enable type checks based on instance types provided by the embedder) | |
| type: bool default: --no-embedder-instance-types | |
| --expose-gc (expose gc extension) | |
| type: bool default: --no-expose-gc | |
| --expose-gc-as (expose gc extension under the specified name) | |
| type: string default: --expose-gc-as="" | |
| --expose-externalize-string (expose externalize string extension) | |
| type: bool default: --no-expose-externalize-string | |
| --expose-statistics (expose statistics extension) | |
| type: bool default: --no-expose-statistics | |
| --expose-trigger-failure (expose trigger-failure extension) | |
| type: bool default: --no-expose-trigger-failure | |
| --expose-ignition-statistics (expose ignition-statistics extension (requires building with v8_enable_ignition_dispatch_counting)) | |
| type: bool default: --no-expose-ignition-statistics | |
| --stack-trace-limit (number of stack frames to capture) | |
| type: int default: --stack-trace-limit=10 | |
| --builtins-in-stack-traces (show built-in functions in stack traces) | |
| type: bool default: --no-builtins-in-stack-traces | |
| --experimental-stack-trace-frames (enable experimental frames (API/Builtins) and stack trace layout) | |
| type: bool default: --no-experimental-stack-trace-frames | |
| --disallow-code-generation-from-strings (disallow eval and friends) | |
| type: bool default: --no-disallow-code-generation-from-strings | |
| --expose-async-hooks (expose async_hooks object) | |
| type: bool default: --no-expose-async-hooks | |
| --expose-cputracemark-as (expose cputracemark extension under the specified name) | |
| type: string default: --expose-cputracemark-as="" | |
| --allow-unsafe-function-constructor (allow invoking the function constructor without security checks) | |
| type: bool default: --no-allow-unsafe-function-constructor | |
| --force-slow-path (always take the slow path for builtins) | |
| type: bool default: --no-force-slow-path | |
| --test-small-max-function-context-stub-size (enable testing the function context size overflow path by making the maximum size smaller) | |
| type: bool default: --no-test-small-max-function-context-stub-size | |
| --inline-new (use fast inline allocation) | |
| type: bool default: --inline-new | |
| --switch-table-spread-threshold (allow the jump table used for switch statements to span a range of integers roughly equal to this number times the number of clauses in the switch) | |
| type: int default: --switch-table-spread-threshold=3 | |
| --switch-table-min-cases (the number of Smi integer cases present in the switch statement before using the jump table optimization) | |
| type: int default: --switch-table-min-cases=6 | |
| --trace (trace javascript function calls) | |
| type: bool default: --no-trace | |
| --lazy (use lazy compilation) | |
| type: bool default: --lazy | |
| --lazy-eval (use lazy compilation during eval) | |
| type: bool default: --lazy-eval | |
| --lazy-streaming (use lazy compilation during streaming compilation) | |
| type: bool default: --lazy-streaming | |
| --max-lazy (ignore eager compilation hints) | |
| type: bool default: --no-max-lazy | |
| --trace-opt (trace optimized compilation) | |
| type: bool default: --no-trace-opt | |
| --trace-opt-verbose (extra verbose optimized compilation tracing) | |
| type: bool default: --no-trace-opt-verbose | |
| --trace-opt-stats (trace optimized compilation statistics) | |
| type: bool default: --no-trace-opt-stats | |
| --trace-deopt (trace deoptimization) | |
| type: bool default: --no-trace-deopt | |
| --log-deopt (log deoptimization) | |
| type: bool default: --no-log-deopt | |
| --trace-deopt-verbose (extra verbose deoptimization tracing) | |
| type: bool default: --no-trace-deopt-verbose | |
| --trace-file-names (include file names in trace-opt/trace-deopt output) | |
| type: bool default: --no-trace-file-names | |
| --always-turbofan (always try to optimize functions) | |
| type: bool default: --no-always-turbofan | |
| --always-osr (always try to OSR functions) | |
| type: bool default: --no-always-osr | |
| --prepare-always-turbofan (prepare for turning on always opt) | |
| type: bool default: --no-prepare-always-turbofan | |
| --deopt-to-baseline (deoptimize to baseline code when available) | |
| type: bool default: --deopt-to-baseline | |
| --trace-serializer (print code serializer trace) | |
| type: bool default: --no-trace-serializer | |
| --compilation-cache (enable compilation cache) | |
| type: bool default: --compilation-cache | |
| --cache-prototype-transitions (cache prototype transitions) | |
| type: bool default: --cache-prototype-transitions | |
| --lazy-compile-dispatcher (enable compiler dispatcher) | |
| type: bool default: --no-lazy-compile-dispatcher | |
| --lazy-compile-dispatcher-max-threads (max threads for compiler dispatcher (0 for unbounded)) | |
| type: uint default: --lazy-compile-dispatcher-max-threads=0 | |
| --trace-compiler-dispatcher (trace compiler dispatcher activity) | |
| type: bool default: --no-trace-compiler-dispatcher | |
| --parallel-compile-tasks-for-eager-toplevel (spawn parallel compile tasks for eagerly compiled, top-level functions) | |
| type: bool default: --no-parallel-compile-tasks-for-eager-toplevel | |
| --parallel-compile-tasks-for-lazy (spawn parallel compile tasks for all lazily compiled functions) | |
| type: bool default: --no-parallel-compile-tasks-for-lazy | |
| --cpu-profiler-sampling-interval (CPU profiler sampling interval in microseconds) | |
| type: int default: --cpu-profiler-sampling-interval=1000 | |
| --trace-side-effect-free-debug-evaluate (print debug messages for side-effect-free debug-evaluate for testing) | |
| type: bool default: --no-trace-side-effect-free-debug-evaluate | |
| --hard-abort (abort by crashing) | |
| type: bool default: --hard-abort | |
| --experimental-value-unavailable (enable experimental <value unavailable> in scopes) | |
| type: bool default: --no-experimental-value-unavailable | |
| --experimental-reuse-locals-blocklists (enable reuse of local blocklists across multiple debug-evaluates) | |
| type: bool default: --experimental-reuse-locals-blocklists | |
| --experimental-remove-internal-scopes-property (don't report the artificial [[Scopes]] property for functions) | |
| type: bool default: --experimental-remove-internal-scopes-property | |
| --log-colour (When logging, try to use coloured output.) | |
| type: bool default: --log-colour | |
| --expose-inspector-scripts (expose injected-script-source.js for debugging) | |
| type: bool default: --no-expose-inspector-scripts | |
| --stack-size (default size of stack region v8 is allowed to use (in kBytes)) | |
| type: int default: --stack-size=864 | |
| --max-stack-trace-source-length (maximum length of function source code printed in a stack trace.) | |
| type: int default: --max-stack-trace-source-length=300 | |
| --clear-exceptions-on-js-entry (clear pending exceptions when entering JavaScript) | |
| type: bool default: --no-clear-exceptions-on-js-entry | |
| --histogram-interval (time interval in ms for aggregating memory histograms) | |
| type: int default: --histogram-interval=600000 | |
| --heap-profiler-trace-objects (Dump heap object allocations/movements/size_updates) | |
| type: bool default: --no-heap-profiler-trace-objects | |
| --heap-profiler-use-embedder-graph (Use the new EmbedderGraph API to get embedder nodes) | |
| type: bool default: --heap-profiler-use-embedder-graph | |
| --heap-snapshot-string-limit (truncate strings to this length in the heap snapshot) | |
| type: int default: --heap-snapshot-string-limit=1024 | |
| --heap-profiler-show-hidden-objects (use 'native' rather than 'hidden' node type in snapshot) | |
| type: bool default: --no-heap-profiler-show-hidden-objects | |
| --sampling-heap-profiler-suppress-randomness (Use constant sample intervals to eliminate test flakiness) | |
| type: bool default: --no-sampling-heap-profiler-suppress-randomness | |
| --use-idle-notification (Use idle notification to reduce memory footprint.) | |
| type: bool default: --use-idle-notification | |
| --log-ic (Log inline cache state transitions for tools/ic-processor) | |
| type: bool default: --no-log-ic | |
| --max-valid-polymorphic-map-count (maximum number of valid maps to track in POLYMORPHIC state) | |
| type: int default: --max-valid-polymorphic-map-count=4 | |
| --native-code-counters (generate extra code for manipulating stats counters) | |
| type: bool default: --no-native-code-counters | |
| --super-ic (use an IC for super property loads) | |
| type: bool default: --super-ic | |
| --enable-mega-dom-ic (use MegaDOM IC state for API objects) | |
| type: bool default: --no-enable-mega-dom-ic | |
| --trace-prototype-users (Trace updates to prototype user tracking) | |
| type: bool default: --no-trace-prototype-users | |
| --trace-for-in-enumerate (Trace for-in enumerate slow-paths) | |
| type: bool default: --no-trace-for-in-enumerate | |
| --log-maps (Log map creation) | |
| type: bool default: --no-log-maps | |
| --log-maps-details (Also log map details) | |
| type: bool default: --log-maps-details | |
| --allow-natives-syntax (allow natives syntax) | |
| type: bool default: --no-allow-natives-syntax | |
| --allow-natives-for-differential-fuzzing (allow only natives explicitly allowlisted for differential fuzzers) | |
| type: bool default: --no-allow-natives-for-differential-fuzzing | |
| --parse-only (only parse the sources) | |
| type: bool default: --no-parse-only | |
| --sim-abort-on-bad-auth (Stop execution when a pointer authentication fails in the ARM64 simulator.) | |
| type: bool default: --sim-abort-on-bad-auth | |
| --async-stack-traces (include async stack traces in Error.stack) | |
| type: bool default: --async-stack-traces | |
| --stack-trace-on-illegal (print stack trace when an illegal exception is thrown) | |
| type: bool default: --no-stack-trace-on-illegal | |
| --abort-on-uncaught-exception (abort program (dump core) when an uncaught exception is thrown) | |
| type: bool default: --no-abort-on-uncaught-exception | |
| --correctness-fuzzer-suppressions (Suppress certain unspecified behaviors to ease correctness fuzzing: Abort program when the stack overflows or a string exceeds maximum length (as opposed to throwing RangeError). Use a fixed suppression string for error messages.) | |
| type: bool default: --no-correctness-fuzzer-suppressions | |
| --rehash-snapshot (rehash strings from the snapshot to override the baked-in seed) | |
| type: bool default: --rehash-snapshot | |
| --hash-seed (Fixed seed to use to hash property keys (0 means random)(with snapshots this option cannot override the baked-in seed)) | |
| type: uint64 default: --hash-seed=0 | |
| --random-seed (Default seed for initializing random generator (0, the default, means to use system random).) | |
| type: int default: --random-seed=0 | |
| --fuzzer-random-seed (Default seed for initializing fuzzer random generator (0, the default, means to use v8's random number generator seed).) | |
| type: int default: --fuzzer-random-seed=0 | |
| --trace-rail (trace RAIL mode) | |
| type: bool default: --no-trace-rail | |
| --print-all-exceptions (print exception object and stack trace on each thrown exception) | |
| type: bool default: --no-print-all-exceptions | |
| --detailed-error-stack-trace (includes arguments for each function call in the error stack frames array) | |
| type: bool default: --no-detailed-error-stack-trace | |
| --adjust-os-scheduling-parameters (adjust OS specific scheduling params for the isolate) | |
| type: bool default: --adjust-os-scheduling-parameters | |
| --experimental-flush-embedded-blob-icache (Used in an experiment to evaluate icache flushing on certain CPUs) | |
| type: bool default: --experimental-flush-embedded-blob-icache | |
| --short-builtin-calls (Put embedded builtins code into the code range for shorter builtin calls/jumps if system has >=4GB memory) | |
| type: bool default: --short-builtin-calls | |
| --runtime-call-stats (report runtime call counts and times) | |
| type: bool default: --no-runtime-call-stats | |
| --rcs (report runtime call counts and times) | |
| type: bool default: --no-rcs | |
| --rcs-cpu-time (report runtime times in cpu time (the default is wall time)) | |
| type: bool default: --no-rcs-cpu-time | |
| --verify-snapshot-checksum (Verify snapshot checksums when deserializing snapshots. Enable checksum creation and verification for code caches. Enabled by default in debug builds and once per process for Android.) | |
| type: bool default: --no-verify-snapshot-checksum | |
| --profile-deserialization (Print the time it takes to deserialize the snapshot.) | |
| type: bool default: --no-profile-deserialization | |
| --serialization-statistics (Collect statistics on serialized objects.) | |
| type: bool default: --no-serialization-statistics | |
| --regexp-optimization (generate optimized regexp code) | |
| type: bool default: --regexp-optimization | |
| --regexp-interpret-all (interpret all regexp code) | |
| type: bool default: --no-regexp-interpret-all | |
| --regexp-tier-up (enable regexp interpreter and tier up to the compiler after the number of executions set by the tier up ticks flag) | |
| type: bool default: --regexp-tier-up | |
| --regexp-tier-up-ticks (set the number of executions for the regexp interpreter before tiering-up to the compiler) | |
| type: int default: --regexp-tier-up-ticks=1 | |
| --regexp-peephole-optimization (enable peephole optimization for regexp bytecode) | |
| type: bool default: --regexp-peephole-optimization | |
| --trace-regexp-peephole-optimization (trace regexp bytecode peephole optimization) | |
| type: bool default: --no-trace-regexp-peephole-optimization | |
| --trace-regexp-bytecodes (trace regexp bytecode execution) | |
| type: bool default: --no-trace-regexp-bytecodes | |
| --trace-regexp-assembler (trace regexp macro assembler calls.) | |
| type: bool default: --no-trace-regexp-assembler | |
| --trace-regexp-parser (trace regexp parsing) | |
| type: bool default: --no-trace-regexp-parser | |
| --trace-regexp-tier-up (trace regexp tiering up execution) | |
| type: bool default: --no-trace-regexp-tier-up | |
| --trace-regexp-graph (trace the regexp graph) | |
| type: bool default: --no-trace-regexp-graph | |
| --enable-experimental-regexp-engine (recognize regexps with 'l' flag, run them on experimental engine) | |
| type: bool default: --no-enable-experimental-regexp-engine | |
| --default-to-experimental-regexp-engine (run regexps with the experimental engine where possible) | |
| type: bool default: --no-default-to-experimental-regexp-engine | |
| --trace-experimental-regexp-engine (trace execution of experimental regexp engine) | |
| type: bool default: --no-trace-experimental-regexp-engine | |
| --enable-experimental-regexp-engine-on-excessive-backtracks (fall back to a breadth-first regexp engine on excessive backtracking) | |
| type: bool default: --no-enable-experimental-regexp-engine-on-excessive-backtracks | |
| --regexp-backtracks-before-fallback (number of backtracks during regexp execution before fall back to experimental engine if enable_experimental_regexp_engine_on_excessive_backtracks is set) | |
| type: uint default: --regexp-backtracks-before-fallback=50000 | |
| --testing-bool-flag (testing_bool_flag) | |
| type: bool default: --testing-bool-flag | |
| --testing-maybe-bool-flag (testing_maybe_bool_flag) | |
| type: maybe_bool default: --testing-maybe-bool-flag=unset | |
| --testing-int-flag (testing_int_flag) | |
| type: int default: --testing-int-flag=13 | |
| --testing-float-flag (float-flag) | |
| type: float default: --testing-float-flag=2.5 | |
| --testing-string-flag (string-flag) | |
| type: string default: --testing-string-flag="Hello, world!" | |
| --testing-prng-seed (Seed used for threading test randomness) | |
| type: int default: --testing-prng-seed=42 | |
| --testing-d8-test-runner (test runner turns on this flag to enable a check that the function was prepared for optimization before marking it for optimization) | |
| type: bool default: --no-testing-d8-test-runner | |
| --fuzzing (Fuzzers use this flag to signal that they are ... fuzzing. This causes intrinsics to fail silently (e.g. return undefined) on invalid usage.) | |
| type: bool default: --no-fuzzing | |
| --freeze-flags-after-init (Disallow changes to flag values after initializing V8) | |
| type: bool default: --freeze-flags-after-init | |
| --embedded-src (Path for the generated embedded data file. (mksnapshot only)) | |
| type: string default: --embedded-src="" | |
| --embedded-variant (Label to disambiguate symbols in embedded data file. (mksnapshot only)) | |
| type: string default: --embedded-variant="" | |
| --startup-src (Write V8 startup as C++ src. (mksnapshot only)) | |
| type: string default: --startup-src="" | |
| --startup-blob (Write V8 startup blob file. (mksnapshot only)) | |
| type: string default: --startup-blob="" | |
| --target-arch (The mksnapshot target arch. (mksnapshot only)) | |
| type: string default: --target-arch="" | |
| --target-os (The mksnapshot target os. (mksnapshot only)) | |
| type: string default: --target-os="" | |
| --target-is-simulator (Instruct mksnapshot that the target is meant to run in the simulator and it can generate simulator-specific instructions. (mksnapshot only)) | |
| type: bool default: --no-target-is-simulator | |
| --turbo-profiling-input (Path of the input file containing basic block counters for builtins. (mksnapshot only)) | |
| type: string default: --turbo-profiling-input="" | |
| --text-is-readable (Whether the .text section of binary can be read) | |
| type: bool default: --text-is-readable | |
| --trace-minor-mc-parallel-marking (trace parallel marking for the young generation) | |
| type: bool default: --no-trace-minor-mc-parallel-marking | |
| --minor-mc (perform young generation mark compact GCs) | |
| type: bool default: --no-minor-mc | |
| --concurrent-minor-mc-marking (perform young generation marking concurrently) | |
| type: bool default: --no-concurrent-minor-mc-marking | |
| --help (Print usage message, including flags, on console) | |
| type: bool default: --help | |
| --print-flag-values (Print all flag values of V8) | |
| type: bool default: --no-print-flag-values | |
| --slow-histograms (Enable slow histograms with more overhead.) | |
| type: bool default: --no-slow-histograms | |
| --use-external-strings (Use external strings for source code) | |
| type: bool default: --no-use-external-strings | |
| --map-counters (Map counters to a file) | |
| type: string default: --map-counters="" | |
| --mock-arraybuffer-allocator (Use a mock ArrayBuffer allocator for testing.) | |
| type: bool default: --no-mock-arraybuffer-allocator | |
| --mock-arraybuffer-allocator-limit (Memory limit for mock ArrayBuffer allocator used to simulate OOM for testing.) | |
| type: size_t default: --mock-arraybuffer-allocator-limit=0 | |
| --logfile (Specify the name of the log file, use '-' for console, '+' for a temporary file.) | |
| type: string default: --logfile="v8.log" | |
| --logfile-per-isolate (Separate log files for each isolate.) | |
| type: bool default: --logfile-per-isolate | |
| --log (Minimal logging (no API, code, GC, suspect, or handles samples).) | |
| type: bool default: --no-log | |
| --log-all (Log all events to the log file.) | |
| type: bool default: --no-log-all | |
| --log-source-code (Log source code.) | |
| type: bool default: --no-log-source-code | |
| --log-source-position (Log detailed source information.) | |
| type: bool default: --no-log-source-position | |
| --log-code (Log code events to the log file without profiling.) | |
| type: bool default: --no-log-code | |
| --log-feedback-vector (Log FeedbackVectors on first creation) | |
| type: bool default: --no-log-feedback-vector | |
| --log-code-disassemble (Log all disassembled code to the log file.) | |
| type: bool default: --no-log-code-disassemble | |
| --log-function-events (Log function events (parse, compile, execute) separately.) | |
| type: bool default: --no-log-function-events | |
| --detailed-line-info (Always generate detailed line information for CPU profiling.) | |
| type: bool default: --no-detailed-line-info | |
| --prof-sampling-interval (Interval for --prof samples (in microseconds).) | |
| type: int default: --prof-sampling-interval=1000 | |
| --prof-cpp (Like --prof, but ignore generated code.) | |
| type: bool default: --no-prof-cpp | |
| --prof-browser-mode (Used with --prof, turns on browser-compatible mode for profiling.) | |
| type: bool default: --prof-browser-mode | |
| --prof (Log statistical profiling information (implies --log-code).) | |
| type: bool default: --no-prof | |
| --ll-prof (Enable low-level linux profiler.) | |
| type: bool default: --no-ll-prof | |
| --gc-fake-mmap (Specify the name of the file for fake gc mmap used in ll_prof) | |
| type: string default: --gc-fake-mmap="/tmp/__v8_gc__" | |
| --log-internal-timer-events (Time internal events.) | |
| type: bool default: --no-log-internal-timer-events | |
| --redirect-code-traces (output deopt information and disassembly into file code-<pid>-<isolate id>.asm) | |
| type: bool default: --no-redirect-code-traces | |
| --redirect-code-traces-to (output deopt information and disassembly into the given file) | |
| type: string default: --redirect-code-traces-to="" | |
| --print-opt-source (print source code of optimized and inlined functions) | |
| type: bool default: --no-print-opt-source | |
| --vtune-prof-annotate-wasm (Used when v8_enable_vtunejit is enabled, load wasm source map and provide annotate support (experimental).) | |
| type: bool default: --no-vtune-prof-annotate-wasm | |
| --win64-unwinding-info (Enable unwinding info for Windows/x64) | |
| type: bool default: --win64-unwinding-info | |
| --interpreted-frames-native-stack (Show interpreted frames on the native stack (useful for external profilers).) | |
| type: bool default: --no-interpreted-frames-native-stack | |
| --predictable (enable predictable mode) | |
| type: bool default: --no-predictable | |
| --predictable-gc-schedule (Predictable garbage collection schedule. Fixes heap growing, idle, and memory reducing behavior.) | |
| type: bool default: --no-predictable-gc-schedule | |
| --single-threaded (disable the use of background tasks) | |
| type: bool default: --no-single-threaded | |
| --single-threaded-gc (disable the use of background gc tasks) | |
| type: bool default: --no-single-threaded-gc | |
| --experimental-web-snapshots (enable Web Snapshots) | |
| type: bool default: --no-experimental-web-snapshots |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment