flags-0.11.md

Table of Contents generated with DocToc

• use_strict false {Boolean}
• es_staging false {Boolean}
  • Implications
• harmony_typeof false {Boolean}
  • Resources
• harmony_scoping false {Boolean}
• harmony_modules false {Boolean}
  • Implications
  • References
• harmony_symbols false {Boolean}
• harmony_proxies false {Boolean}
  • Resources
• harmony_collections false {Boolean}
  • References
• harmony_generators false {Boolean}
• harmony_iteration false {Boolean}
• harmony_numeric_literals false {Boolean}
• harmony_strings false {Boolean}
• harmony_arrays false {Boolean}
• harmony_maths false {Boolean}
• harmony false {Boolean}
  • Implications
• packed_arrays true {Boolean}
• smi_only_arrays true {Boolean}
• compiled_keyed_dictionary_loads true {Boolean}
• clever_optimizations true {Boolean}
• pretenuring true {Boolean}
• pretenuring_call_new false {Boolean}
• allocation_site_pretenuring true {Boolean}
• trace_pretenuring false {Boolean}
• trace_pretenuring_statistics false {Boolean}
• track_fields true {Boolean}
• track_double_fields true {Boolean}
  • Implications
• track_heap_object_fields true {Boolean}
  • Implications
• track_computed_fields true {Boolean}
  • Implications
• smi_binop true {Boolean}
• optimize_for_size false {Boolean}
• unbox_double_arrays true {Boolean}
• string_slices true {Boolean}
• crankshaft true {Boolean}
  • Resources
• hydrogen_filter * {String}
• use_gvn true {Boolean}
• gvn_iterations 3 {Integer}
• use_canonicalizing true {Boolean}
• use_inlining true {Boolean}
• use_escape_analysis true {Boolean}
• use_allocation_folding true {Boolean}
• use_local_allocation_folding false {Boolean}
• use_write_barrier_elimination true {Boolean}
• max_inlining_levels 5 {Integer}
• max_inlined_source_size 600 {Integer}
• max_inlined_nodes 196 {Integer}
• max_inlined_nodes_cumulative 400 {Integer}
• loop_invariant_code_motion true {Boolean}
• fast_math true {Boolean}
• collect_megamorphic_maps_from_stub_cache true {Boolean}
• hydrogen_stats false {Boolean}
• trace_check_elimination false {Boolean}
• trace_hydrogen false {Boolean}
• trace_hydrogen_filter * {String}
• trace_hydrogen_stubs false {Boolean}
• trace_hydrogen_file undefined {String}
• trace_phase HLZ {String}
• trace_inlining false {Boolean}
• trace_load_elimination false {Boolean}
• trace_store_elimination false {Boolean}
• trace_alloc false {Boolean}
• trace_all_uses false {Boolean}
• trace_range false {Boolean}
• trace_gvn false {Boolean}
• trace_representation false {Boolean}
• trace_escape_analysis false {Boolean}
• trace_allocation_folding false {Boolean}
• trace_track_allocation_sites false {Boolean}
• trace_migration false {Boolean}
• trace_generalization false {Boolean}
• stress_pointer_maps false {Boolean}
• stress_environments false {Boolean}
• deopt_every_n_times 0 {Integer}
• deopt_every_n_garbage_collections 0 {Integer}
• print_deopt_stress false {Boolean}
• trap_on_deopt false {Boolean}
• trap_on_stub_deopt false {Boolean}
• deoptimize_uncommon_cases true {Boolean}
• polymorphic_inlining true {Boolean}
• use_osr true {Boolean}
• array_bounds_checks_elimination true {Boolean}
• trace_bce false {Boolean}
• array_bounds_checks_hoisting false {Boolean}
• array_index_dehoisting true {Boolean}
• analyze_environment_liveness true {Boolean}
• load_elimination true {Boolean}
• check_elimination true {Boolean}
  • Resources
• store_elimination false {Boolean}
• dead_code_elimination true {Boolean}
  • Resources
• fold_constants true {Boolean}
• trace_dead_code_elimination false {Boolean}
• unreachable_code_elimination true {Boolean}
• trace_osr false {Boolean}
• stress_runs 0 {Integer}
• optimize_closures true {Boolean}
• lookup_sample_by_shared true {Boolean}
• cache_optimized_code true {Boolean}
• flush_optimized_code_cache true {Boolean}
• inline_construct true {Boolean}
• inline_arguments true {Boolean}
• inline_accessors true {Boolean}
• escape_analysis_iterations 2 {Integer}
• optimize_for_in true {Boolean}
• opt_safe_uint32_operations true {Boolean}
• concurrent_recompilation true {Boolean}
• trace_concurrent_recompilation false {Boolean}
• concurrent_recompilation_queue_length 8 {Integer}
• concurrent_recompilation_delay 0 {Integer}
• block_concurrent_recompilation false {Boolean}
• concurrent_osr false {Boolean}
  • Implications
• omit_map_checks_for_leaf_maps true {Boolean}
• typed_array_max_size_in_heap 64 {Integer}
• frame_count 1 {Integer}
• interrupt_budget 6144 {Integer}
• type_info_threshold 25 {Integer}
• self_opt_count 130 {Integer}
• trace_opt_verbose false {Boolean}
  • Implications
• debug_code false {Boolean}
• code_comments false {Boolean}
  • Resources
• enable_sse2 true {Boolean}
• enable_sse3 true {Boolean}
• enable_sse4_1 true {Boolean}
• enable_cmov true {Boolean}
• enable_sahf true {Boolean}
• enable_vfp3 true {Boolean}
• enable_armv7 true {Boolean}
• enable_neon true {Boolean}
• enable_sudiv true {Boolean}
• enable_movw_movt false {Boolean}
• enable_unaligned_accesses true {Boolean}
• enable_32dregs true {Boolean}
• enable_vldr_imm false {Boolean}
• force_long_branches false {Boolean}
• expose_natives_as undefined {String}
• expose_debug_as undefined {String}
• expose_free_buffer false {Boolean}
• expose_gc false {Boolean}
• expose_gc_as undefined {String}
  • Implications
• expose_externalize_string false {Boolean}
• expose_trigger_failure false {Boolean}
• stack_trace_limit 10 {Integer}
• builtins_in_stack_traces false {Boolean}
• disable_native_files false {Boolean}
• inline_new true {Boolean}
• trace_codegen false {Boolean}
• trace false {Boolean}
• mask_constants_with_cookie true {Boolean}
• lazy true {Boolean}
• trace_opt false {Boolean}
• trace_opt_stats false {Boolean}
• opt true {Boolean}
• always_opt false {Boolean}
• always_osr false {Boolean}
  • Resources:
• prepare_always_opt false {Boolean}
• trace_deopt false {Boolean}
• trace_stub_failures false {Boolean}
• min_preparse_length 1024 {Integer}
• always_full_compiler false {Boolean}
• max_opt_count 10 {Integer}
• compilation_cache true {Boolean}
  • Resources
• cache_prototype_transitions true {Boolean}
  • Resources:
• cpu_profiler_sampling_interval 1000 {Integer}
• trace_debug_json false {Boolean}
• trace_js_array_abuse false {Boolean}
• trace_external_array_abuse false {Boolean}
• trace_array_abuse false {Boolean}
  • Implications
• debugger_auto_break true {Boolean}
• enable_liveedit true {Boolean}
• hard_abort true {Boolean}
• stack_size 984 {Integer}
• max_stack_trace_source_length 300 {Integer}
• always_inline_smi_code false {Boolean}
• max_new_space_size 0 {Integer}
• max_old_space_size 0 {Integer}
• max_executable_size 0 {Integer}
• gc_global false {Boolean}
• gc_interval -1 {Integer}
• trace_gc false {Boolean}
• trace_gc_nvp false {Boolean}
• trace_gc_ignore_scavenger false {Boolean}
• print_cumulative_gc_stat false {Boolean}
• print_max_heap_committed false {Boolean}
• trace_gc_verbose false {Boolean}
• trace_fragmentation false {Boolean}
• trace_external_memory false {Boolean}
• collect_maps true {Boolean}
• weak_embedded_maps_in_optimized_code true {Boolean}
• weak_embedded_objects_in_optimized_code true {Boolean}
• flush_code true {Boolean}
• flush_code_incrementally true {Boolean}
• trace_code_flushing false {Boolean}
• age_code true {Boolean}
• incremental_marking true {Boolean}
• incremental_marking_steps true {Boolean}
• trace_incremental_marking false {Boolean}
• track_gc_object_stats false {Boolean}
• parallel_sweeping true {Boolean}
• concurrent_sweeping false {Boolean}
  • Resources
• sweeper_threads 0 {Integer}
• job_based_sweeping false {Boolean}
• heap_profiler_trace_objects false {Boolean}
• use_idle_notification true {Boolean}
• use_ic true {Boolean}
• native_code_counters false {Boolean}
• always_compact false {Boolean}
• lazy_sweeping true {Boolean}
• never_compact false {Boolean}
• compact_code_space true {Boolean}
• incremental_code_compaction true {Boolean}
• cleanup_code_caches_at_gc true {Boolean}
• use_marking_progress_bar true {Boolean}
• zap_code_space true {Boolean}
• random_seed 0 {Integer}
• use_verbose_printer true {Boolean}
• allow_natives_syntax false {Boolean}
• trace_parse false {Boolean}
• trace_sim false {Boolean}
• debug_sim false {Boolean}
  • Resources
• check_icache false {Boolean}
• stop_sim_at 0 {Integer}
• sim_stack_alignment 8 {Integer}
• sim_stack_size 2048 {Integer}
• log_regs_modified true {Boolean}
• log_colour true {Boolean}
• ignore_asm_unimplemented_break false {Boolean}
• trace_sim_messages false {Boolean}
• stack_trace_on_illegal false {Boolean}
• abort_on_uncaught_exception false {Boolean}
• randomize_hashes true {Boolean}
• hash_seed 0 {Integer}
• profile_deserialization false {Boolean}
• regexp_optimization true {Boolean}
• testing_string_flag Hello, world! {String}
• testing_serialization_file /tmp/serdes {String}
• extra_code undefined {String}
• profile_hydrogen_code_stub_compilation false {Boolean}
• predictable false {Boolean}
  • Negative implications
• help false {Boolean}
• dump_counters false {Boolean}
• map_counters `` {String}
• debug_compile_events true {Boolean}
  • Resources
• debug_script_collected_events true {Boolean}
• gdbjit false {Boolean}
• gdbjit_full false {Boolean}
• gdbjit_dump false {Boolean}
• gdbjit_dump_filter `` {String}
• force_marking_deque_overflows false {Boolean}
• stress_compaction false {Boolean}
• print_source false {Boolean}
• print_builtin_source false {Boolean}
• print_ast false {Boolean}
• print_builtin_ast false {Boolean}
• stop_at `` {String}
• trap_on_abort false {Boolean}
• print_builtin_scopes false {Boolean}
• print_scopes false {Boolean}
• trace_contexts false {Boolean}
• gc_greedy false {Boolean}
• gc_verbose false {Boolean}
• heap_stats false {Boolean}
• code_stats false {Boolean}
  • Resources
• verify_native_context_separation false {Boolean}
• print_handles false {Boolean}
• print_global_handles false {Boolean}
• trace_ic false {Boolean}
• print_interfaces false {Boolean}
• print_interface_details false {Boolean}
• print_interface_depth 5 {Integer}
• trace_normalization false {Boolean}
• trace_lazy false {Boolean}
• collect_heap_spill_statistics false {Boolean}
• trace_isolates false {Boolean}
• regexp_possessive_quantifier false {Boolean}
• trace_regexp_bytecodes false {Boolean}
• trace_regexp_assembler false {Boolean}
• log false {Boolean}
• log_all false {Boolean}
• log_runtime false {Boolean}
• log_api false {Boolean}
• log_code false {Boolean}
• log_gc false {Boolean}
• log_handles false {Boolean}
• log_snapshot_positions false {Boolean}
• log_suspect false {Boolean}
• prof false {Boolean}
• prof_browser_mode true {Boolean}
• log_regexp false {Boolean}
• logfile v8.log {String}
• logfile_per_isolate true {Boolean}
• ll_prof false {Boolean}
• perf_basic_prof false {Boolean}
• perf_jit_prof false {Boolean}
• gc_fake_mmap /tmp/__v8_gc__ {String}
• log_internal_timer_events false {Boolean}
  • Implications
• log_timer_events false {Boolean}
  • Implications
• log_instruction_stats false {Boolean}
• log_instruction_file arm64_inst.csv {String}
• log_instruction_period 4194304 {Integer}
• redirect_code_traces false {Boolean}
• redirect_code_traces_to undefined {String}
• hydrogen_track_positions false {Boolean}
• trace_elements_transitions false {Boolean}
• trace_creation_allocation_sites false {Boolean}
• print_code_stubs false {Boolean}
• test_secondary_stub_cache false {Boolean}
• test_primary_stub_cache false {Boolean}
• print_code false {Boolean}
• print_opt_code false {Boolean}
• print_unopt_code false {Boolean}
• print_code_verbose false {Boolean}
• print_builtin_code false {Boolean}
• enable_ool_constant_pool false {Boolean}

use_strict false {Boolean}

enforce strict mode

• default: false
• type: Boolean
• readonly: false

es_staging false {Boolean}

enable upcoming ES6+ features

• default: false
• type: Boolean
• readonly: false

Implications

• harmony_maths

harmony_typeof false {Boolean}

enable harmony semantics for typeof

• default: false
• type: Boolean
• readonly: false

Note: this feature seems to work in v8 even without turning on this flag.

Resources

• rejected? proposal

harmony_scoping false {Boolean}

enable harmony block scoping

• default: false
• type: Boolean
• readonly: false

harmony_modules false {Boolean}

enable harmony modules (implies block scoping)

• default: false
• type: Boolean
• readonly: false

Implications

• harmony_scoping

References

• spec
• v8 parser.cc

harmony_symbols false {Boolean}

enable harmony symbols (a.k.a. private names)

• default: false
• type: Boolean
• readonly: false

harmony_proxies false {Boolean}

enable harmony proxies

NOTE: This flag cannot be configured after the process started up!

• default: false
• type: Boolean
• readonly: false

Resources

• v8 bootstrapper.cc
• spec draft

harmony_collections false {Boolean}

enable harmony collections (sets, maps)

NOTE: This flag cannot be configured after the process started up!

• default: false
• type: Boolean
• readonly: false

References

• v8 bootstrapper.cc
• example

harmony_generators false {Boolean}

enable harmony generators

• default: false
• type: Boolean
• readonly: false

harmony_iteration false {Boolean}

enable harmony iteration (for-of)

• default: false
• type: Boolean
• readonly: false

harmony_numeric_literals false {Boolean}

enable harmony numeric literals (0o77, 0b11)

• default: false
• type: Boolean
• readonly: false

harmony_strings false {Boolean}

enable harmony string

• default: false
• type: Boolean
• readonly: false

harmony_arrays false {Boolean}

enable harmony arrays

• default: false
• type: Boolean
• readonly: false

harmony_maths false {Boolean}

enable harmony math functions

• default: false
• type: Boolean
• readonly: false

harmony false {Boolean}

enable all harmony features (except typeof)

• default: false
• type: Boolean
• readonly: false

Implications

• harmony_scoping
• harmony_modules
• harmony_symbols
• harmony_proxies
• harmony_collections
• harmony_generators
• harmony_iteration
• harmony_numeric_literals
• harmony_strings
• harmony_arrays
• es_staging

packed_arrays true {Boolean}

optimizes arrays that have no holes

• default: true
• type: Boolean
• readonly: false

smi_only_arrays true {Boolean}

tracks arrays with only smi values

• default: true
• type: Boolean
• readonly: false

compiled_keyed_dictionary_loads true {Boolean}

use optimizing compiler to generate keyed dictionary load stubs

• default: true
• type: Boolean
• readonly: false

clever_optimizations true {Boolean}

Optimize object size, Array shift, DOM strings and string +

• default: true
• type: Boolean
• readonly: false

pretenuring true {Boolean}

allocate objects in old space

• default: true
• type: Boolean
• readonly: false

pretenuring_call_new false {Boolean}

pretenure call new

• default: false
• type: Boolean
• readonly: false

allocation_site_pretenuring true {Boolean}

pretenure with allocation sites

• default: true
• type: Boolean
• readonly: false

trace_pretenuring false {Boolean}

trace pretenuring decisions of HAllocate instructions

• default: false
• type: Boolean
• readonly: false

trace_pretenuring_statistics false {Boolean}

trace allocation site pretenuring statistics

• default: false
• type: Boolean
• readonly: false

track_fields true {Boolean}

track fields with only smi values

• default: true
• type: Boolean
• readonly: false

track_double_fields true {Boolean}

track fields with double values

• default: true
• type: Boolean
• readonly: false

Implications

• track_fields

track_heap_object_fields true {Boolean}

track fields with heap values

• default: true
• type: Boolean
• readonly: false

Implications

• track_fields

track_computed_fields true {Boolean}

track computed boilerplate fields

• default: true
• type: Boolean
• readonly: false

Implications

• track_fields

smi_binop true {Boolean}

support smi representation in binary operations

• default: true
• type: Boolean
• readonly: false

optimize_for_size false {Boolean}

Enables optimizations which favor memory size over execution speed.

• default: false
• type: Boolean
• readonly: false

unbox_double_arrays true {Boolean}

automatically unbox arrays of doubles

• default: true
• type: Boolean
• readonly: false

string_slices true {Boolean}

use string slices

• default: true
• type: Boolean
• readonly: false

crankshaft true {Boolean}

use crankshaft

• default: true
• type: Boolean
• readonly: false

Resources

• v8 isolate.cc
• v8 runtime.cc

hydrogen_filter * {String}

optimization filter

• default: *
• type: String
• readonly: false

use_gvn true {Boolean}

use hydrogen global value numbering

• default: true
• type: Boolean
• readonly: false

gvn_iterations 3 {Integer}

maximum number of GVN fix-point iterations

• default: 3
• type: Integer
• readonly: false

use_canonicalizing true {Boolean}

use hydrogen instruction canonicalizing

• default: true
• type: Boolean
• readonly: false

use_inlining true {Boolean}

use function inlining

• default: true
• type: Boolean
• readonly: false

use_escape_analysis true {Boolean}

use hydrogen escape analysis

• default: true
• type: Boolean
• readonly: false

use_allocation_folding true {Boolean}

use allocation folding

• default: true
• type: Boolean
• readonly: false

use_local_allocation_folding false {Boolean}

only fold in basic blocks

• default: false
• type: Boolean
• readonly: false

use_write_barrier_elimination true {Boolean}

eliminate write barriers targeting allocations in optimized code

• default: true
• type: Boolean
• readonly: false

max_inlining_levels 5 {Integer}

maximum number of inlining levels

• default: 5
• type: Integer
• readonly: false

max_inlined_source_size 600 {Integer}

maximum source size in bytes considered for a single inlining

• default: 600
• type: Integer
• readonly: false

max_inlined_nodes 196 {Integer}

maximum number of AST nodes considered for a single inlining

• default: 196
• type: Integer
• readonly: false

max_inlined_nodes_cumulative 400 {Integer}

maximum cumulative number of AST nodes considered for inlining

• default: 400
• type: Integer
• readonly: false

loop_invariant_code_motion true {Boolean}

loop invariant code motion

• default: true
• type: Boolean
• readonly: false

fast_math true {Boolean}

faster (but maybe less accurate) math functions

• default: true
• type: Boolean
• readonly: false

collect_megamorphic_maps_from_stub_cache true {Boolean}

crankshaft harvests type feedback from stub cache

• default: true
• type: Boolean
• readonly: false

hydrogen_stats false {Boolean}

print statistics for hydrogen

• default: false
• type: Boolean
• readonly: false

trace_check_elimination false {Boolean}

trace check elimination phase

• default: false
• type: Boolean
• readonly: false

trace_hydrogen false {Boolean}

trace generated hydrogen to file

• default: false
• type: Boolean
• readonly: false

trace_hydrogen_filter * {String}

hydrogen tracing filter

• default: *
• type: String
• readonly: false

trace_hydrogen_stubs false {Boolean}

trace generated hydrogen for stubs

• default: false
• type: Boolean
• readonly: false

trace_hydrogen_file undefined {String}

trace hydrogen to given file name

• default: undefined
• type: String
• readonly: false

trace_phase HLZ {String}

trace generated IR for specified phases

• default: HLZ
• type: String
• readonly: false

trace_inlining false {Boolean}

trace inlining decisions

• default: false
• type: Boolean
• readonly: false

trace_load_elimination false {Boolean}

trace load elimination

• default: false
• type: Boolean
• readonly: false

trace_store_elimination false {Boolean}

trace store elimination

• default: false
• type: Boolean
• readonly: false

trace_alloc false {Boolean}

trace register allocator

• default: false
• type: Boolean
• readonly: false

trace_all_uses false {Boolean}

trace all use positions

• default: false
• type: Boolean
• readonly: false

trace_range false {Boolean}

trace range analysis

• default: false
• type: Boolean
• readonly: false

trace_gvn false {Boolean}

trace global value numbering

• default: false
• type: Boolean
• readonly: false

trace_representation false {Boolean}

trace representation types

• default: false
• type: Boolean
• readonly: false

trace_escape_analysis false {Boolean}

trace hydrogen escape analysis

• default: false
• type: Boolean
• readonly: false

trace_allocation_folding false {Boolean}

trace allocation folding

• default: false
• type: Boolean
• readonly: false

trace_track_allocation_sites false {Boolean}

trace the tracking of allocation sites

• default: false
• type: Boolean
• readonly: false

trace_migration false {Boolean}

trace object migration

• default: false
• type: Boolean
• readonly: false

trace_generalization false {Boolean}

trace map generalization

• default: false
• type: Boolean
• readonly: false

stress_pointer_maps false {Boolean}

pointer map for every instruction

• default: false
• type: Boolean
• readonly: false

stress_environments false {Boolean}

environment for every instruction

• default: false
• type: Boolean
• readonly: false

deopt_every_n_times 0 {Integer}

deoptimize every n times a deopt point is passed

• default: 0
• type: Integer
• readonly: false

deopt_every_n_garbage_collections 0 {Integer}

deoptimize every n garbage collections

• default: 0
• type: Integer
• readonly: false

print_deopt_stress false {Boolean}

print number of possible deopt points

• default: false
• type: Boolean
• readonly: false

trap_on_deopt false {Boolean}

put a break point before deoptimizing

• default: false
• type: Boolean
• readonly: false

trap_on_stub_deopt false {Boolean}

put a break point before deoptimizing a stub

• default: false
• type: Boolean
• readonly: false

deoptimize_uncommon_cases true {Boolean}

deoptimize uncommon cases

• default: true
• type: Boolean
• readonly: false

polymorphic_inlining true {Boolean}

polymorphic inlining

• default: true
• type: Boolean
• readonly: false

use_osr true {Boolean}

use on-stack replacement

• default: true
• type: Boolean
• readonly: false

array_bounds_checks_elimination true {Boolean}

perform array bounds checks elimination

• default: true
• type: Boolean
• readonly: false

trace_bce false {Boolean}

trace array bounds check elimination

• default: false
• type: Boolean
• readonly: false

array_bounds_checks_hoisting false {Boolean}

perform array bounds checks hoisting

• default: false
• type: Boolean
• readonly: false

array_index_dehoisting true {Boolean}

perform array index dehoisting

• default: true
• type: Boolean
• readonly: false

analyze_environment_liveness true {Boolean}

analyze liveness of environment slots and zap dead values

• default: true
• type: Boolean
• readonly: false

load_elimination true {Boolean}

use load elimination

• default: true
• type: Boolean
• readonly: false

check_elimination true {Boolean}

use check elimination

• default: true
• type: Boolean
• readonly: false

Resources

• v8 source

store_elimination false {Boolean}

use store elimination

• default: false
• type: Boolean
• readonly: false

dead_code_elimination true {Boolean}

use dead code elimination

• default: true
• type: Boolean
• readonly: false

Resources

v8 hydrogen.cc v8 hydrogin-dce.cc

Note: not available below node: 0.10 - v8: 3.14

fold_constants true {Boolean}

use constant folding

• default: true
• type: Boolean
• readonly: false

trace_dead_code_elimination false {Boolean}

trace dead code elimination

• default: false
• type: Boolean
• readonly: false

unreachable_code_elimination true {Boolean}

eliminate unreachable code

• default: true
• type: Boolean
• readonly: false

trace_osr false {Boolean}

trace on-stack replacement

• default: false
• type: Boolean
• readonly: false

stress_runs 0 {Integer}

number of stress runs

• default: 0
• type: Integer
• readonly: false

optimize_closures true {Boolean}

optimize closures

• default: true
• type: Boolean
• readonly: false

lookup_sample_by_shared true {Boolean}

when picking a function to optimize, watch for shared function info, not JSFunction itself

• default: true
• type: Boolean
• readonly: false

cache_optimized_code true {Boolean}

cache optimized code for closures

• default: true
• type: Boolean
• readonly: false

flush_optimized_code_cache true {Boolean}

flushes the cache of optimized code for closures on every GC

• default: true
• type: Boolean
• readonly: false

inline_construct true {Boolean}

inline constructor calls

• default: true
• type: Boolean
• readonly: false

inline_arguments true {Boolean}

inline functions with arguments object

• default: true
• type: Boolean
• readonly: false

inline_accessors true {Boolean}

inline JavaScript accessors

• default: true
• type: Boolean
• readonly: false

escape_analysis_iterations 2 {Integer}

maximum number of escape analysis fix-point iterations

• default: 2
• type: Integer
• readonly: false

optimize_for_in true {Boolean}

optimize functions containing for-in loops

• default: true
• type: Boolean
• readonly: false

opt_safe_uint32_operations true {Boolean}

allow uint32 values on optimize frames if they are used only in safe operations

• default: true
• type: Boolean
• readonly: false

concurrent_recompilation true {Boolean}

optimizing hot functions asynchronously on a separate thread

• default: true
• type: Boolean
• readonly: false

trace_concurrent_recompilation false {Boolean}

track concurrent recompilation

• default: false
• type: Boolean
• readonly: false

concurrent_recompilation_queue_length 8 {Integer}

the length of the concurrent compilation queue

• default: 8
• type: Integer
• readonly: false

concurrent_recompilation_delay 0 {Integer}

artificial compilation delay in ms

• default: 0
• type: Integer
• readonly: false

block_concurrent_recompilation false {Boolean}

block queued jobs until released

• default: false
• type: Boolean
• readonly: false

concurrent_osr false {Boolean}

concurrent on-stack replacement

• default: false
• type: Boolean
• readonly: false

Implications

• concurrent_recompilation

omit_map_checks_for_leaf_maps true {Boolean}

do not emit check maps for constant values that have a leaf map, deoptimize the optimized code if the layout of the maps changes.

• default: true
• type: Boolean
• readonly: false

typed_array_max_size_in_heap 64 {Integer}

threshold for in-heap typed array

• default: 64
• type: Integer
• readonly: false

frame_count 1 {Integer}

number of stack frames inspected by the profiler

• default: 1
• type: Integer
• readonly: false

interrupt_budget 6144 {Integer}

execution budget before interrupt is triggered

• default: 6144
• type: Integer
• readonly: false

type_info_threshold 25 {Integer}

percentage of ICs that must have type info to allow optimization

• default: 25
• type: Integer
• readonly: false

self_opt_count 130 {Integer}

call count before self-optimization

• default: 130
• type: Integer
• readonly: false

trace_opt_verbose false {Boolean}

extra verbose compilation tracing

• default: false
• type: Boolean
• readonly: false

Implications

• trace_opt

debug_code false {Boolean}

generate extra code (assertions) for debugging

• default: false
• type: Boolean
• readonly: false

code_comments false {Boolean}

emit comments in code disassembly

• default: false
• type: Boolean
• readonly: false

Resources

• v8 source
• v8 source

Note: not available below node: 0.11 - v8: 3.25

enable_sse2 true {Boolean}

enable use of SSE2 instructions if available

• default: true
• type: Boolean
• readonly: false

enable_sse3 true {Boolean}

enable use of SSE3 instructions if available

• default: true
• type: Boolean
• readonly: false

enable_sse4_1 true {Boolean}

enable use of SSE4.1 instructions if available

• default: true
• type: Boolean
• readonly: false

enable_cmov true {Boolean}

enable use of CMOV instruction if available

• default: true
• type: Boolean
• readonly: false

enable_sahf true {Boolean}

enable use of SAHF instruction if available (X64 only)

• default: true
• type: Boolean
• readonly: false

enable_vfp3 true {Boolean}

enable use of VFP3 instructions if available

• default: true
• type: Boolean
• readonly: false

enable_armv7 true {Boolean}

enable use of ARMv7 instructions if available (ARM only)

• default: true
• type: Boolean
• readonly: false

enable_neon true {Boolean}

enable use of NEON instructions if available (ARM only)

• default: true
• type: Boolean
• readonly: false

enable_sudiv true {Boolean}

enable use of SDIV and UDIV instructions if available (ARM only)

• default: true
• type: Boolean
• readonly: false

enable_movw_movt false {Boolean}

enable loading 32-bit constant by means of movw/movt instruction pairs (ARM only)

• default: false
• type: Boolean
• readonly: false

enable_unaligned_accesses true {Boolean}

enable unaligned accesses for ARMv7 (ARM only)

• default: true
• type: Boolean
• readonly: false

enable_32dregs true {Boolean}

enable use of d16-d31 registers on ARM - this requires VFP3

• default: true
• type: Boolean
• readonly: false

enable_vldr_imm false {Boolean}

enable use of constant pools for double immediate (ARM only)

• default: false
• type: Boolean
• readonly: false

force_long_branches false {Boolean}

force all emitted branches to be in long mode (MIPS only)

• default: false
• type: Boolean
• readonly: false

expose_natives_as undefined {String}

expose natives in global object

NOTE: This flag cannot be configured after the process started up!

• default: undefined
• type: String
• readonly: false

expose_debug_as undefined {String}

expose debug in global object

NOTE: This flag cannot be configured after the process started up!

• default: undefined
• type: String
• readonly: false

expose_free_buffer false {Boolean}

expose freeBuffer extension

• default: false
• type: Boolean
• readonly: false

expose_gc false {Boolean}

expose gc extension

NOTE: This flag cannot be configured after the process started up!

• default: false
• type: Boolean
• readonly: false

expose_gc_as undefined {String}

expose gc extension under the specified name

NOTE: This flag cannot be configured after the process started up!

• default: undefined
• type: String
• readonly: false

Implications

• expose_gc

expose_externalize_string false {Boolean}

expose externalize string extension

• default: false
• type: Boolean
• readonly: false

expose_trigger_failure false {Boolean}

expose trigger-failure extension

• default: false
• type: Boolean
• readonly: false

stack_trace_limit 10 {Integer}

number of stack frames to capture

• default: 10
• type: Integer
• readonly: false

builtins_in_stack_traces false {Boolean}

show built-in functions in stack traces

• default: false
• type: Boolean
• readonly: false

disable_native_files false {Boolean}

disable builtin natives files

• default: false
• type: Boolean
• readonly: false

inline_new true {Boolean}

use fast inline allocation

• default: true
• type: Boolean
• readonly: false

trace_codegen false {Boolean}

print name of functions for which code is generated

• default: false
• type: Boolean
• readonly: false

trace false {Boolean}

trace function calls

• default: false
• type: Boolean
• readonly: false

mask_constants_with_cookie true {Boolean}

use random jit cookie to mask large constants

• default: true
• type: Boolean
• readonly: false

lazy true {Boolean}

use lazy compilation

• default: true
• type: Boolean
• readonly: false

trace_opt false {Boolean}

trace lazy optimization

• default: false
• type: Boolean
• readonly: false

trace_opt_stats false {Boolean}

trace lazy optimization statistics

• default: false
• type: Boolean
• readonly: false

opt true {Boolean}

use adaptive optimizations

• default: true
• type: Boolean
• readonly: false

always_opt false {Boolean}

always try to optimize functions

• default: false
• type: Boolean
• readonly: false

Note: not properly working below node: 0.10 - v8: 3.14

always_osr false {Boolean}

always try to OSR functions

• default: false
• type: Boolean
• readonly: false

OSR (On Stack Replacement) is used to convert a running function’s interpreter frame into a JIT’d frame – in the middle of that method.

Resources:

• Efficient and General On-Stack Replacement for Aggressive Program Specialization
• What the heck is OSR
• v8 source

Note: available starting with node: 0.10 - v8: 3.14

prepare_always_opt false {Boolean}

prepare for turning on always opt

• default: false
• type: Boolean
• readonly: false

trace_deopt false {Boolean}

trace optimize function deoptimization

• default: false
• type: Boolean
• readonly: false

trace_stub_failures false {Boolean}

trace deoptimization of generated code stubs

• default: false
• type: Boolean
• readonly: false

min_preparse_length 1024 {Integer}

minimum length for automatic enable preparsing

• default: 1024
• type: Integer
• readonly: false

always_full_compiler false {Boolean}

try to use the dedicated run-once backend for all code

• default: false
• type: Boolean
• readonly: false

max_opt_count 10 {Integer}

maximum number of optimization attempts before giving up.

• default: 10
• type: Integer
• readonly: false

compilation_cache true {Boolean}

enable compilation cache

• default: true
• type: Boolean
• readonly: false

The compilation cache keeps shared function infos for compiled scripts and evals. The shared function infos are looked up using the source string as the key. For regular expressions the compilation data is cached.

Enable/Disable is used by debugger to disable compilation cache during debugging to make sure new scripts are always compiled, however both this flag and the enabled_ property need to be true in order for the compilation cache to get used.

Resources

• v8 source
• v8 source

cache_prototype_transitions true {Boolean}

cache prototype transitions

• default: true
• type: Boolean
• readonly: false

Resources:

• v8 source

cpu_profiler_sampling_interval 1000 {Integer}

CPU profiler sampling interval in microseconds

• default: 1000
• type: Integer
• readonly: false

trace_debug_json false {Boolean}

trace debugging JSON request/response

• default: false
• type: Boolean
• readonly: false

trace_js_array_abuse false {Boolean}

trace out-of-bounds accesses to JS arrays

• default: false
• type: Boolean
• readonly: false

trace_external_array_abuse false {Boolean}

trace out-of-bounds-accesses to external arrays

• default: false
• type: Boolean
• readonly: false

trace_array_abuse false {Boolean}

trace out-of-bounds accesses to all arrays

• default: false
• type: Boolean
• readonly: false

Implications

• trace_js_array_abuse
• trace_external_array_abuse

debugger_auto_break true {Boolean}

automatically set the debug break flag when debugger commands are in the queue

• default: true
• type: Boolean
• readonly: false

enable_liveedit true {Boolean}

enable liveedit experimental feature

• default: true
• type: Boolean
• readonly: false

hard_abort true {Boolean}

abort by crashing

• default: true
• type: Boolean
• readonly: false

stack_size 984 {Integer}

default size of stack region v8 is allowed to use (in kBytes)

• default: 984
• type: Integer
• readonly: false

max_stack_trace_source_length 300 {Integer}

maximum length of function source code printed in a stack trace.

• default: 300
• type: Integer
• readonly: false

always_inline_smi_code false {Boolean}

always inline smi code in non-opt code

• default: false
• type: Boolean
• readonly: false

max_new_space_size 0 {Integer}

max size of the new generation (in kBytes)

• default: 0
• type: Integer
• readonly: false

max_old_space_size 0 {Integer}

max size of the old generation (in Mbytes)

• default: 0
• type: Integer
• readonly: false

max_executable_size 0 {Integer}

max size of executable memory (in Mbytes)

• default: 0
• type: Integer
• readonly: false

gc_global false {Boolean}

always perform global GCs

• default: false
• type: Boolean
• readonly: false

gc_interval -1 {Integer}

garbage collect after allocations

• default: -1
• type: Integer
• readonly: false

trace_gc false {Boolean}

print one trace line following each garbage collection

• default: false
• type: Boolean
• readonly: false

trace_gc_nvp false {Boolean}

print one detailed trace line in name=value format after each garbage collection

• default: false
• type: Boolean
• readonly: false

trace_gc_ignore_scavenger false {Boolean}

do not print trace line after scavenger collection

• default: false
• type: Boolean
• readonly: false

print_cumulative_gc_stat false {Boolean}

print cumulative GC statistics in name=value format on exit

• default: false
• type: Boolean
• readonly: false

print_max_heap_committed false {Boolean}

print statistics of the maximum memory committed for the heap in name=value format on exit

• default: false
• type: Boolean
• readonly: false

trace_gc_verbose false {Boolean}

print more details following each garbage collection

• default: false
• type: Boolean
• readonly: false

trace_fragmentation false {Boolean}

report fragmentation for old pointer and data pages

• default: false
• type: Boolean
• readonly: false

trace_external_memory false {Boolean}

print amount of external allocated memory after each time it is adjusted.

• default: false
• type: Boolean
• readonly: false

collect_maps true {Boolean}

garbage collect maps from which no objects can be reached

• default: true
• type: Boolean
• readonly: false

weak_embedded_maps_in_optimized_code true {Boolean}

make maps embedded in optimized code weak

• default: true
• type: Boolean
• readonly: false

weak_embedded_objects_in_optimized_code true {Boolean}

make objects embedded in optimized code weak

• default: true
• type: Boolean
• readonly: false

flush_code true {Boolean}

flush code that we expect not to use again (during full gc)

• default: true
• type: Boolean
• readonly: false

flush_code_incrementally true {Boolean}

flush code that we expect not to use again (incrementally)

• default: true
• type: Boolean
• readonly: false

trace_code_flushing false {Boolean}

trace code flushing progress

• default: false
• type: Boolean
• readonly: false

age_code true {Boolean}

track un-executed functions to age code and flush only old code (required for code flushing)

• default: true
• type: Boolean
• readonly: false

incremental_marking true {Boolean}

use incremental marking

• default: true
• type: Boolean
• readonly: false

incremental_marking_steps true {Boolean}

do incremental marking steps

• default: true
• type: Boolean
• readonly: false

trace_incremental_marking false {Boolean}

trace progress of the incremental marking

• default: false
• type: Boolean
• readonly: false

track_gc_object_stats false {Boolean}

track object counts and memory usage

• default: false
• type: Boolean
• readonly: false

parallel_sweeping true {Boolean}

enable parallel sweeping

• default: true
• type: Boolean
• readonly: false

concurrent_sweeping false {Boolean}

enable concurrent sweeping

• default: false
• type: Boolean
• readonly: false

Resources

• v8 mark-compact.cc
• v8 mark-compact.cc
• v8 sweeper-thread.cc

Note: not available below node: 0.11 - v8: 3.25

sweeper_threads 0 {Integer}

number of parallel and concurrent sweeping threads

• default: 0
• type: Integer
• readonly: false

job_based_sweeping false {Boolean}

enable job based sweeping

• default: false
• type: Boolean
• readonly: false

heap_profiler_trace_objects false {Boolean}

Dump heap object allocations/movements/size_updates

• default: false
• type: Boolean
• readonly: false

use_idle_notification true {Boolean}

Use idle notification to reduce memory footprint.

• default: true
• type: Boolean
• readonly: false

use_ic true {Boolean}

use inline caching

• default: true
• type: Boolean
• readonly: false

native_code_counters false {Boolean}

generate extra code for manipulating stats counters

• default: false
• type: Boolean
• readonly: false

always_compact false {Boolean}

Perform compaction on every full GC

• default: false
• type: Boolean
• readonly: false

lazy_sweeping true {Boolean}

Use lazy sweeping for old pointer and data spaces

• default: true
• type: Boolean
• readonly: false

never_compact false {Boolean}

Never perform compaction on full GC - testing only

• default: false
• type: Boolean
• readonly: false

compact_code_space true {Boolean}

Compact code space on full non-incremental collections

• default: true
• type: Boolean
• readonly: false

incremental_code_compaction true {Boolean}

Compact code space on full incremental collections

• default: true
• type: Boolean
• readonly: false

cleanup_code_caches_at_gc true {Boolean}

Flush inline caches prior to mark compact collection and flush code caches in maps during mark compact cycle.

• default: true
• type: Boolean
• readonly: false

use_marking_progress_bar true {Boolean}

Use a progress bar to scan large objects in increments when incremental marking is active.

• default: true
• type: Boolean
• readonly: false

zap_code_space true {Boolean}

Zap free memory in code space with 0xCC while sweeping.

• default: true
• type: Boolean
• readonly: false

random_seed 0 {Integer}

Default seed for initializing random generator (0, the default, means to use system random).

• default: 0
• type: Integer
• readonly: false

use_verbose_printer true {Boolean}

allows verbose printing

• default: true
• type: Boolean
• readonly: false

allow_natives_syntax false {Boolean}

allow natives syntax

• default: false
• type: Boolean
• readonly: false

trace_parse false {Boolean}

trace parsing and preparsing

• default: false
• type: Boolean
• readonly: false

trace_sim false {Boolean}

Trace simulator execution

• default: false
• type: Boolean
• readonly: false

debug_sim false {Boolean}

Enable debugging the simulator

• default: false
• type: Boolean
• readonly: false

At this point this is only used inside the arm64 simulator.

Resources

v8 arm64/simulator-arm64.cc

Note: not available below node: 0.11 - v8: 3.25

check_icache false {Boolean}

Check icache flushes in ARM and MIPS simulator

• default: false
• type: Boolean
• readonly: false

stop_sim_at 0 {Integer}

Simulator stop after x number of instructions

• default: 0
• type: Integer
• readonly: false

sim_stack_alignment 8 {Integer}

Stack alingment in bytes in simulator (4 or 8, 8 is default)

• default: 8
• type: Integer
• readonly: false

sim_stack_size 2048 {Integer}

Stack size of the ARM64 simulator in kBytes (default is 2 MB)

• default: 2048
• type: Integer
• readonly: false

log_regs_modified true {Boolean}

When logging register values, only print modified registers.

• default: true
• type: Boolean
• readonly: false

log_colour true {Boolean}

When logging, try to use coloured output.

• default: true
• type: Boolean
• readonly: false

ignore_asm_unimplemented_break false {Boolean}

Don't break for ASM_UNIMPLEMENTED_BREAK macros.

• default: false
• type: Boolean
• readonly: false

trace_sim_messages false {Boolean}

Trace simulator debug messages. Implied by --trace-sim.

• default: false
• type: Boolean
• readonly: false

stack_trace_on_illegal false {Boolean}

print stack trace when an illegal exception is thrown

• default: false
• type: Boolean
• readonly: false

abort_on_uncaught_exception false {Boolean}

abort program (dump core) when an uncaught exception is thrown

• default: false
• type: Boolean
• readonly: false

randomize_hashes true {Boolean}

randomize hashes to avoid predictable hash collisions (with snapshots this option cannot override the baked-in seed)

• default: true
• type: Boolean
• readonly: false

hash_seed 0 {Integer}

Fixed seed to use to hash property keys (0 means random)(with snapshots this option cannot override the baked-in seed)

• default: 0
• type: Integer
• readonly: false

profile_deserialization false {Boolean}

Print the time it takes to deserialize the snapshot.

• default: false
• type: Boolean
• readonly: false

regexp_optimization true {Boolean}

generate optimized regexp code

• default: true
• type: Boolean
• readonly: false

testing_string_flag Hello, world! {String}

string-flag

• default: Hello, world!
• type: String
• readonly: false

testing_serialization_file /tmp/serdes {String}

file in which to serialize heap

• default: /tmp/serdes
• type: String
• readonly: false

extra_code undefined {String}

A filename with extra code to be included in the snapshot (mksnapshot only)

• default: undefined
• type: String
• readonly: false

profile_hydrogen_code_stub_compilation false {Boolean}

Print the time it takes to lazily compile hydrogen code stubs.

• default: false
• type: Boolean
• readonly: false

predictable false {Boolean}

enable predictable mode

• default: false
• type: Boolean
• readonly: false

Negative implications

• concurrent_recompilation
• concurrent_osr
• concurrent_sweeping
• parallel_sweeping

help false {Boolean}

Print usage message, including flags, on console

• default: false
• type: Boolean
• readonly: false

dump_counters false {Boolean}

Dump counters on exit

• default: false
• type: Boolean
• readonly: false

map_counters `` {String}

Map counters to a file

• default: ``
• type: String
• readonly: false

debug_compile_events true {Boolean}

Enable debugger compile events

• default: true
• type: Boolean
• readonly: false

Resources

v8 debug.h

Note: disabled by default on WebOS

debug_script_collected_events true {Boolean}

Enable debugger script collected events

• default: true
• type: Boolean
• readonly: false

gdbjit false {Boolean}

enable GDBJIT interface (disables compacting GC)

• default: false
• type: Boolean
• readonly: false

gdbjit_full false {Boolean}

enable GDBJIT interface for all code objects

• default: false
• type: Boolean
• readonly: false

gdbjit_dump false {Boolean}

dump elf objects with debug info to disk

• default: false
• type: Boolean
• readonly: false

gdbjit_dump_filter `` {String}

dump only objects containing this substring

• default: ``
• type: String
• readonly: false

force_marking_deque_overflows false {Boolean}

force overflows of marking deque by reducing it's size to 64 words

• default: false
• type: Boolean
• readonly: false

stress_compaction false {Boolean}

stress the GC compactor to flush out bugs (implies --force_marking_deque_overflows)

• default: false
• type: Boolean
• readonly: false

print_source false {Boolean}

pretty print source code

• default: false
• type: Boolean
• readonly: true

print_builtin_source false {Boolean}

pretty print source code for builtins

• default: false
• type: Boolean
• readonly: true

print_ast false {Boolean}

print source AST

• default: false
• type: Boolean
• readonly: true

print_builtin_ast false {Boolean}

print source AST for builtins

• default: false
• type: Boolean
• readonly: true

stop_at `` {String}

function name where to insert a breakpoint

• default: ``
• type: String
• readonly: true

trap_on_abort false {Boolean}

replace aborts by breakpoints

• default: false
• type: Boolean
• readonly: true

print_builtin_scopes false {Boolean}

print scopes for builtins

• default: false
• type: Boolean
• readonly: true

print_scopes false {Boolean}

print scopes

• default: false
• type: Boolean
• readonly: true

trace_contexts false {Boolean}

trace contexts operations

• default: false
• type: Boolean
• readonly: true

gc_greedy false {Boolean}

perform GC prior to some allocations

• default: false
• type: Boolean
• readonly: true

gc_verbose false {Boolean}

print stuff during garbage collection

• default: false
• type: Boolean
• readonly: true

heap_stats false {Boolean}

report heap statistics before and after GC

• default: false
• type: Boolean
• readonly: true

code_stats false {Boolean}

report code statistics after GC

• default: false
• type: Boolean
• readonly: true

Resources

• v8 source
• v8 source

verify_native_context_separation false {Boolean}

verify that code holds on to at most one native context after GC

• default: false
• type: Boolean
• readonly: true

print_handles false {Boolean}

report handles after GC

• default: false
• type: Boolean
• readonly: true

print_global_handles false {Boolean}

report global handles after GC

• default: false
• type: Boolean
• readonly: true

trace_ic false {Boolean}

trace inline cache state transitions

• default: false
• type: Boolean
• readonly: true

print_interfaces false {Boolean}

print interfaces

• default: false
• type: Boolean
• readonly: true

print_interface_details false {Boolean}

print interface inference details

• default: false
• type: Boolean
• readonly: true

print_interface_depth 5 {Integer}

depth for printing interfaces

• default: 5
• type: Integer
• readonly: true

trace_normalization false {Boolean}

prints when objects are turned into dictionaries.

• default: false
• type: Boolean
• readonly: true

trace_lazy false {Boolean}

trace lazy compilation

• default: false
• type: Boolean
• readonly: true

collect_heap_spill_statistics false {Boolean}

report heap spill statistics along with heap_stats (requires heap_stats)

• default: false
• type: Boolean
• readonly: true

trace_isolates false {Boolean}

trace isolate state changes

• default: false
• type: Boolean
• readonly: true

regexp_possessive_quantifier false {Boolean}

enable possessive quantifier syntax for testing

• default: false
• type: Boolean
• readonly: true

trace_regexp_bytecodes false {Boolean}

trace regexp bytecode execution

• default: false
• type: Boolean
• readonly: true

trace_regexp_assembler false {Boolean}

trace regexp macro assembler calls.

• default: false
• type: Boolean
• readonly: true

log false {Boolean}

Minimal logging (no API, code, GC, suspect, or handles samples).

• default: false
• type: Boolean
• readonly: false

log_all false {Boolean}

Log all events to the log file.

• default: false
• type: Boolean
• readonly: false

log_runtime false {Boolean}

Activate runtime system %Log call.

• default: false
• type: Boolean
• readonly: false

log_api false {Boolean}

Log API events to the log file.

• default: false
• type: Boolean
• readonly: false

log_code false {Boolean}

Log code events to the log file without profiling.

• default: false
• type: Boolean
• readonly: false

log_gc false {Boolean}

Log heap samples on garbage collection for the hp2ps tool.

• default: false
• type: Boolean
• readonly: false

log_handles false {Boolean}

Log global handle events.

• default: false
• type: Boolean
• readonly: false

log_snapshot_positions false {Boolean}

log positions of (de)serialized objects in the snapshot.

• default: false
• type: Boolean
• readonly: false

log_suspect false {Boolean}

Log suspect operations.

• default: false
• type: Boolean
• readonly: false

prof false {Boolean}

Log statistical profiling information (implies --log-code).

• default: false
• type: Boolean
• readonly: false

prof_browser_mode true {Boolean}

Used with --prof, turns on browser-compatible mode for profiling.

• default: true
• type: Boolean
• readonly: false

log_regexp false {Boolean}

Log regular expression execution.

• default: false
• type: Boolean
• readonly: false

logfile v8.log {String}

Specify the name of the log file.

• default: v8.log
• type: String
• readonly: false

logfile_per_isolate true {Boolean}

Separate log files for each isolate.

• default: true
• type: Boolean
• readonly: false

ll_prof false {Boolean}

Enable low-level linux profiler.

• default: false
• type: Boolean
• readonly: false

perf_basic_prof false {Boolean}

Enable perf linux profiler (basic support).

• default: false
• type: Boolean
• readonly: false

perf_jit_prof false {Boolean}

Enable perf linux profiler (experimental annotate support).

• default: false
• type: Boolean
• readonly: false

gc_fake_mmap /tmp/__v8_gc__ {String}

Specify the name of the file for fake gc mmap used in ll_prof

• default: /tmp/__v8_gc__
• type: String
• readonly: false

log_internal_timer_events false {Boolean}

Time internal events.

• default: false
• type: Boolean
• readonly: false

Implications

• prof

log_timer_events false {Boolean}

Time events including external callbacks.

• default: false
• type: Boolean
• readonly: false

Implications

• log_internal_timer_events

log_instruction_stats false {Boolean}

Log AArch64 instruction statistics.

• default: false
• type: Boolean
• readonly: false

log_instruction_file arm64_inst.csv {String}

AArch64 instruction statistics log file.

• default: arm64_inst.csv
• type: String
• readonly: false

log_instruction_period 4194304 {Integer}

AArch64 instruction statistics logging period.

• default: 4194304
• type: Integer
• readonly: false

redirect_code_traces false {Boolean}

output deopt information and disassembly into file code--.asm

• default: false
• type: Boolean
• readonly: false

redirect_code_traces_to undefined {String}

output deopt information and disassembly into the given file

• default: undefined
• type: String
• readonly: false

hydrogen_track_positions false {Boolean}

track source code positions when building IR

• default: false
• type: Boolean
• readonly: false

trace_elements_transitions false {Boolean}

trace elements transitions

• default: false
• type: Boolean
• readonly: true

trace_creation_allocation_sites false {Boolean}

trace the creation of allocation sites

• default: false
• type: Boolean
• readonly: true

print_code_stubs false {Boolean}

print code stubs

• default: false
• type: Boolean
• readonly: true

test_secondary_stub_cache false {Boolean}

test secondary stub cache by disabling the primary one

• default: false
• type: Boolean
• readonly: true

test_primary_stub_cache false {Boolean}

test primary stub cache by disabling the secondary one

• default: false
• type: Boolean
• readonly: true

print_code false {Boolean}

print generated code

• default: false
• type: Boolean
• readonly: true

print_opt_code false {Boolean}

print optimized code

• default: false
• type: Boolean
• readonly: true

print_unopt_code false {Boolean}

print unoptimized code before printing optimized code based on it

• default: false
• type: Boolean
• readonly: true

print_code_verbose false {Boolean}

print more information for code

• default: false
• type: Boolean
• readonly: true

print_builtin_code false {Boolean}

print generated code for builtins

• default: false
• type: Boolean
• readonly: true

enable_ool_constant_pool false {Boolean}

enable use of out-of-line constant pools (ARM only)

• default: false
• type: Boolean
• readonly: true