v8  3.14.5(node0.10.28)
V8 is Google's open source JavaScript engine
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Macros | Functions | Variables
flag-definitions.h File Reference
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros

#define DEFINE_bool(nam, def, cmt)   FLAG(BOOL, bool, nam, def, cmt)
 
#define DEFINE_int(nam, def, cmt)   FLAG(INT, int, nam, def, cmt)
 
#define DEFINE_float(nam, def, cmt)   FLAG(FLOAT, double, nam, def, cmt)
 
#define DEFINE_string(nam, def, cmt)   FLAG(STRING, const char*, nam, def, cmt)
 
#define DEFINE_args(nam, def, cmt)   FLAG(ARGS, JSArguments, nam, def, cmt)
 
#define FLAG   FLAG_FULL
 
#define FLAG   FLAG_READONLY
 
#define FLAG   FLAG_FULL
 
#define FLAG   FLAG_READONLY
 
#define FLAG_FULL(ftype, ctype, nam, def, cmt)   ctype FLAG_##nam = def;
 
#define FLAG_READONLY(ftype, ctype, nam, def, cmt)
 
#define DEFINE_implication(whenflag, thenflag)
 
#define DEFINE_bool(nam, def, cmt)   FLAG(BOOL, bool, nam, def, cmt)
 
#define DEFINE_int(nam, def, cmt)   FLAG(INT, int, nam, def, cmt)
 
#define DEFINE_float(nam, def, cmt)   FLAG(FLOAT, double, nam, def, cmt)
 
#define DEFINE_string(nam, def, cmt)   FLAG(STRING, const char*, nam, def, cmt)
 
#define DEFINE_args(nam, def, cmt)   FLAG(ARGS, JSArguments, nam, def, cmt)
 
#define FLAG   FLAG_FULL
 
#define FLAG   FLAG_READONLY
 
#define FLAG   FLAG_FULL
 
#define FLAG   FLAG_READONLY
 
#define FLAG_FULL(ftype, ctype, nam, def, cmt)   static ctype const FLAGDEFAULT_##nam = def;
 
#define FLAG_READONLY(ftype, ctype, nam, def, cmt)
 
#define DEFINE_implication(whenflag, thenflag)
 
#define DEFINE_bool(nam, def, cmt)   FLAG(BOOL, bool, nam, def, cmt)
 
#define DEFINE_int(nam, def, cmt)   FLAG(INT, int, nam, def, cmt)
 
#define DEFINE_float(nam, def, cmt)   FLAG(FLOAT, double, nam, def, cmt)
 
#define DEFINE_string(nam, def, cmt)   FLAG(STRING, const char*, nam, def, cmt)
 
#define DEFINE_args(nam, def, cmt)   FLAG(ARGS, JSArguments, nam, def, cmt)
 
#define FLAG   FLAG_FULL
 
#define FLAG   FLAG_READONLY
 
#define FLAG   FLAG_FULL
 
#define FLAG   FLAG_READONLY
 
#define FLAG_FULL(ftype, ctype, nam, def, cmt)   { Flag::TYPE_##ftype, #nam, &FLAG_##nam, &FLAGDEFAULT_##nam, cmt, false },
 
#define FLAG_READONLY(ftype, ctype, nam, def, cmt)
 
#define DEFINE_implication(whenflag, thenflag)
 
#define DEFINE_bool(nam, def, cmt)   FLAG(BOOL, bool, nam, def, cmt)
 
#define DEFINE_int(nam, def, cmt)   FLAG(INT, int, nam, def, cmt)
 
#define DEFINE_float(nam, def, cmt)   FLAG(FLOAT, double, nam, def, cmt)
 
#define DEFINE_string(nam, def, cmt)   FLAG(STRING, const char*, nam, def, cmt)
 
#define DEFINE_args(nam, def, cmt)   FLAG(ARGS, JSArguments, nam, def, cmt)
 
#define FLAG   FLAG_FULL
 
#define FLAG   FLAG_READONLY
 
#define FLAG   FLAG_FULL
 
#define FLAG   FLAG_READONLY
 
#define FLAG_FULL(ftype, ctype, nam, def, cmt)
 
#define FLAG_READONLY(ftype, ctype, nam, def, cmt)
 
#define DEFINE_implication(whenflag, thenflag)   if (FLAG_##whenflag) FLAG_##thenflag = true;
 
#define DEFINE_bool(nam, def, cmt)   FLAG(BOOL, bool, nam, def, cmt)
 
#define DEFINE_int(nam, def, cmt)   FLAG(INT, int, nam, def, cmt)
 
#define DEFINE_float(nam, def, cmt)   FLAG(FLOAT, double, nam, def, cmt)
 
#define DEFINE_string(nam, def, cmt)   FLAG(STRING, const char*, nam, def, cmt)
 
#define DEFINE_args(nam, def, cmt)   FLAG(ARGS, JSArguments, nam, def, cmt)
 
#define FLAG   FLAG_FULL
 
#define FLAG   FLAG_READONLY
 
#define FLAG   FLAG_FULL
 
#define FLAG   FLAG_READONLY
 
#define FLAG_FULL(ftype, ctype, nam, def, cmt)   extern ctype FLAG_##nam;
 
#define FLAG_READONLY(ftype, ctype, nam, def, cmt)   static ctype const FLAG_##nam = def;
 
#define DEFINE_implication(whenflag, thenflag)
 
#define JSARGUMENTS_INIT   {{}}
 
#define DEFINE_bool(nam, def, cmt)   FLAG(BOOL, bool, nam, def, cmt)
 
#define DEFINE_int(nam, def, cmt)   FLAG(INT, int, nam, def, cmt)
 
#define DEFINE_float(nam, def, cmt)   FLAG(FLOAT, double, nam, def, cmt)
 
#define DEFINE_string(nam, def, cmt)   FLAG(STRING, const char*, nam, def, cmt)
 
#define DEFINE_args(nam, def, cmt)   FLAG(ARGS, JSArguments, nam, def, cmt)
 
#define FLAG   FLAG_FULL
 
#define FLAG   FLAG_READONLY
 
#define FLAG   FLAG_FULL
 
#define FLAG   FLAG_READONLY
 

Functions

 DEFINE_bool (use_strict, false,"enforce strict mode") DEFINE_bool(es5_readonly
 
activate correct semantics for
inheriting readonliness 		DEFINE_bool (es52_globals, true,"activate new semantics for global var declarations") DEFINE_bool(harmony_typeof
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof 		DEFINE_bool (harmony_scoping, false,"enable harmony block scoping") DEFINE_bool(harmony_modules
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony 		modules (implies block scoping)") DEFINE_bool(harmony_proxies
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies 		DEFINE_bool (harmony_collections, false,"enable harmony collections (sets, maps, and weak maps)") DEFINE_bool(harmony
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony 		features (except typeof)") DEFINE_implication(harmony
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping 		DEFINE_implication (harmony, harmony_modules) DEFINE_implication(harmony
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies 		DEFINE_implication (harmony, harmony_collections) DEFINE_implication(harmony_modules
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping 		DEFINE_bool (packed_arrays, true,"optimizes arrays that have no holes") DEFINE_bool(smi_only_arrays
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values 		DEFINE_bool (clever_optimizations, true,"Optimize object size, Array shift, DOM strings and string +") DEFINE_bool(unbox_double_arrays
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles 		DEFINE_bool (string_slices, true,"use string slices") DEFINE_bool(crankshaft
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft 		DEFINE_string (hydrogen_filter,"","optimization filter") DEFINE_bool(use_range
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis 		DEFINE_bool (eliminate_dead_phis, true,"eliminate dead phis") DEFINE_bool(use_gvn
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering 		DEFINE_bool (use_canonicalizing, true,"use hydrogen instruction canonicalizing") DEFINE_bool(use_inlining
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining 		DEFINE_int (max_inlined_source_size, 600,"maximum source size in bytes considered for a single inlining") DEFINE_int(max_inlined_nodes
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining 		DEFINE_int (max_inlined_nodes_cumulative, 196,"maximum cumulative number of AST nodes considered for inlining") DEFINE_bool(loop_invariant_code_motion
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion 		DEFINE_bool (collect_megamorphic_maps_from_stub_cache, true,"crankshaft harvests type feedback from stub cache") DEFINE_bool(hydrogen_stats
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen 		DEFINE_bool (trace_hydrogen, false,"trace generated hydrogen to file") DEFINE_string(trace_phase
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases 		DEFINE_bool (trace_inlining, false,"trace inlining decisions") DEFINE_bool(trace_alloc
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator 		DEFINE_bool (trace_all_uses, false,"trace all use positions") DEFINE_bool(trace_range
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis 		DEFINE_bool (trace_gvn, false,"trace global value numbering") DEFINE_bool(trace_representation
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types 		DEFINE_bool (stress_pointer_maps, false,"pointer map for every instruction") DEFINE_bool(stress_environments
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction 		DEFINE_int (deopt_every_n_times, 0,"deoptimize every n times a deopt point is passed") DEFINE_bool(trap_on_deopt
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing 		DEFINE_bool (deoptimize_uncommon_cases, true,"deoptimize uncommon cases") DEFINE_bool(polymorphic_inlining
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining 		DEFINE_bool (use_osr, true,"use on-stack replacement") DEFINE_bool(array_bounds_checks_elimination
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination 		DEFINE_bool (array_index_dehoisting, true,"perform array index dehoisting") DEFINE_bool(dead_code_elimination
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination 		DEFINE_bool (trace_dead_code_elimination, false,"trace dead code elimination") DEFINE_bool(trace_osr
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement 		DEFINE_int (stress_runs, 0,"number of stress runs") DEFINE_bool(optimize_closures
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures 		DEFINE_bool (lookup_sample_by_shared, true,"when picking a function to optimize, watch for shared function ""info, not JSFunction itself") DEFINE_bool(cache_optimized_code
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures 		DEFINE_bool (inline_construct, true,"inline constructor calls") DEFINE_bool(inline_arguments
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object 		DEFINE_bool (inline_accessors, true,"inline JavaScript accessors") DEFINE_int(loop_weight
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference 		DEFINE_bool (optimize_for_in, true,"optimize functions containing for-in loops") DEFINE_bool(opt_safe_uint32_operations
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations 		DEFINE_bool (parallel_recompilation, false,"optimizing hot functions asynchronously on a separate thread") DEFINE_bool(trace_parallel_recompilation
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation 		DEFINE_int (parallel_recompilation_queue_length, 2,"the length of the parallel compilation queue") DEFINE_bool(experimental_profiler
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments 		DEFINE_bool (watch_ic_patching, false,"profiler considers IC stability") DEFINE_int(frame_count
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler 		DEFINE_bool (self_optimization, false,"primitive functions trigger their own optimization") DEFINE_bool(direct_self_opt
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing 		DEFINE_bool (retry_self_opt, false,"re-try self-optimization if it failed") DEFINE_bool(count_based_interrupts
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing 		DEFINE_bool (interrupt_at_exit, false,"insert an interrupt check at function exit") DEFINE_bool(weighted_back_edges
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering 		DEFINE_int (interrupt_budget, 0x1700,"execution budget before interrupt is triggered") DEFINE_int(type_info_threshold
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization 		DEFINE_int (self_opt_count, 130,"call count before self-optimization") DEFINE_implication(experimental_profiler
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching 		DEFINE_implication (experimental_profiler, self_optimization) DEFINE_implication(experimental_profiler
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt 		DEFINE_implication (experimental_profiler, count_based_interrupts) DEFINE_implication(experimental_profiler
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit 		DEFINE_implication (experimental_profiler, weighted_back_edges) DEFINE_bool(trace_opt_verbose
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing 		DEFINE_implication (trace_opt_verbose, trace_opt) DEFINE_bool(debug_code
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra 		code (assertions) for debugging") DEFINE_bool(code_comments
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly 		DEFINE_bool (enable_sse2, true,"enable use of SSE2 instructions if available") DEFINE_bool(enable_sse3
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available 		DEFINE_bool (enable_sse4_1, true,"enable use of SSE4.1 instructions if available") DEFINE_bool(enable_cmov
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available 		DEFINE_bool (enable_rdtsc, true,"enable use of RDTSC instruction if available") DEFINE_bool(enable_sahf
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if 		available (X64 only)") DEFINE_bool(enable_vfp3
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 		instructions (ARM only)") DEFINE_bool(enable_vfp2
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available 		DEFINE_bool (enable_armv7, true,"enable use of ARMv7 instructions if available (ARM only)") DEFINE_bool(enable_sudiv
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if 		available (ARM only)") DEFINE_bool(enable_movw_movt
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction 		pairs (ARM only)") DEFINE_bool(enable_unaligned_accesses
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for 		ARMv7 (ARM only)") DEFINE_bool(enable_fpu
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if 		available (MIPS only)") DEFINE_string(expose_natives_as
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object 		DEFINE_string (expose_debug_as, NULL,"expose debug in global object") DEFINE_bool(expose_gc
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension 		DEFINE_bool (expose_externalize_string, false,"expose externalize string extension") DEFINE_int(stack_trace_limit
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture 		DEFINE_bool (builtins_in_stack_traces, false,"show built-in functions in stack traces") DEFINE_bool(disable_native_files
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files 		DEFINE_bool (inline_new, true,"use fast inline allocation") DEFINE_bool(stack_trace_on_abort
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs 		DEFINE_bool (trace, false,"trace function calls") DEFINE_bool(mask_constants_with_cookie
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants 		DEFINE_bool (lazy, true,"use lazy compilation") DEFINE_bool(trace_opt
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization 		DEFINE_bool (trace_opt_stats, false,"trace lazy optimization statistics") DEFINE_bool(opt
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations 		DEFINE_bool (always_opt, false,"always try to optimize functions") DEFINE_bool(prepare_always_opt
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt 		DEFINE_bool (trace_deopt, false,"trace deoptimization") DEFINE_int(min_preparse_length
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing 		DEFINE_bool (always_full_compiler, false,"try to use the dedicated run-once backend for all code") DEFINE_int(max_opt_count
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up 		DEFINE_bool (compilation_cache, true,"enable compilation cache") DEFINE_bool(cache_prototype_transitions
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions 		DEFINE_bool (trace_debug_json, false,"trace debugging JSON request/response") DEFINE_bool(debugger_auto_break
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue 		DEFINE_bool (enable_liveedit, true,"enable liveedit experimental feature") DEFINE_bool(break_on_abort
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting 		DEFINE_int (stack_size, kPointerSize *123,"default size of stack region v8 is allowed to use (in kBytes)") DEFINE_int(max_stack_trace_source_length
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace 		DEFINE_bool (always_inline_smi_code, false,"always inline smi code in non-opt code") DEFINE_int(max_new_space_size
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new 		generation (in kBytes)") DEFINE_int(max_old_space_size
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable 		memory (in Mbytes)") DEFINE_bool(gc_global
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs 		DEFINE_int (gc_interval,-1,"garbage collect after <n> allocations") DEFINE_bool(trace_gc
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection 		DEFINE_bool (trace_gc_nvp, false,"print one detailed trace line in name=value format ""after each garbage collection") DEFINE_bool(trace_gc_ignore_scavenger
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection 		DEFINE_bool (print_cumulative_gc_stat, false,"print cumulative GC statistics in name=value format on exit") DEFINE_bool(trace_gc_verbose
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection 		DEFINE_bool (trace_fragmentation, false,"report fragmentation for old pointer and data pages") DEFINE_bool(trace_external_memory
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted 		DEFINE_bool (collect_maps, true,"garbage collect maps from which no objects can be reached") DEFINE_bool(flush_code
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc 		DEFINE_bool (incremental_marking, true,"use incremental marking") DEFINE_bool(incremental_marking_steps
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps 		DEFINE_bool (trace_incremental_marking, false,"trace progress of the incremental marking") DEFINE_bool(track_gc_object_stats
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage 		DEFINE_bool (use_idle_notification, true,"Use idle notification to reduce memory footprint.") DEFINE_bool(use_ic
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching 		DEFINE_bool (native_code_counters, false,"generate extra code for manipulating stats counters") DEFINE_bool(always_compact
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC 		DEFINE_bool (lazy_sweeping, true,"Use lazy sweeping for old pointer and data spaces") DEFINE_bool(never_compact
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only 		DEFINE_bool (compact_code_space, true,"Compact code space on full non-incremental collections") DEFINE_bool(incremental_code_compaction
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections 		DEFINE_bool (cleanup_code_caches_at_gc, true,"Flush inline caches prior to mark compact collection and ""flush code caches in maps during mark compact cycle.") DEFINE_int(random_seed
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random 		generator (0, the default, means to use system random).") DEFINE_bool(use_verbose_printer
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing 		DEFINE_bool (allow_natives_syntax, false,"allow natives syntax") DEFINE_bool(trace_parse
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing 		DEFINE_bool (trace_sim, false,"Trace simulator execution") DEFINE_bool(check_icache
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator 		DEFINE_int (stop_sim_at, 0,"Simulator stop after x number of instructions") DEFINE_int(sim_stack_alignment
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator Stack
alingment in bytes in 		simulator (4 or 8, 8 is default)") DEFINE_bool(trace_exception
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator Stack
alingment in bytes in print
stack trace when throwing
exceptions 		DEFINE_bool (preallocate_message_memory, false,"preallocate some memory to build stack traces.") DEFINE_bool(randomize_hashes
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator Stack
alingment in bytes in print
stack trace when throwing
exceptions randomize hashes to
avoid predictable hash 		collisions (with snapshots this option cannot override the baked-in seed)") DEFINE_int(hash_seed
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator Stack
alingment in bytes in print
stack trace when throwing
exceptions randomize hashes to
avoid predictable hash Fixed
seed to use to hash property 		keys (0 means random)" "(with snapshots this option cannot override the baked-in seed)") DEFINE_bool(preemption
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator Stack
alingment in bytes in print
stack trace when throwing
exceptions randomize hashes to
avoid predictable hash Fixed
seed to use to hash property
activate a timer that switches
between V8 threads 		DEFINE_bool (regexp_optimization, true,"generate optimized regexp code") DEFINE_bool(testing_bool_flag
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator Stack
alingment in bytes in print
stack trace when throwing
exceptions randomize hashes to
avoid predictable hash Fixed
seed to use to hash property
activate a timer that switches
between V8 threads
testing_bool_flag 		DEFINE_int (testing_int_flag, 13,"testing_int_flag") DEFINE_float(testing_float_flag
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator Stack
alingment in bytes in print
stack trace when throwing
exceptions randomize hashes to
avoid predictable hash Fixed
seed to use to hash property
activate a timer that switches
between V8 threads
testing_bool_flag float flag 		DEFINE_string (testing_string_flag,"Hello, world!","string-flag") DEFINE_int(testing_prng_seed
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator Stack
alingment in bytes in print
stack trace when throwing
exceptions randomize hashes to
avoid predictable hash Fixed
seed to use to hash property
activate a timer that switches
between V8 threads
testing_bool_flag float flag
Seed used for threading test
randomness 		DEFINE_string (testing_serialization_file,"/tmp/serdes","file in which to serialize heap") DEFINE_string(extra_code
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator Stack
alingment in bytes in print
stack trace when throwing
exceptions randomize hashes to
avoid predictable hash Fixed
seed to use to hash property
activate a timer that switches
between V8 threads
testing_bool_flag float flag
Seed used for threading test
randomness A filename with
extra code to be included in
the 		snapshot (mksnapshot only)") DEFINE_bool(help
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator Stack
alingment in bytes in print
stack trace when throwing
exceptions randomize hashes to
avoid predictable hash Fixed
seed to use to hash property
activate a timer that switches
between V8 threads
testing_bool_flag float flag
Seed used for threading test
randomness A filename with
extra code to be included in
the Print usage including on
console 		DEFINE_bool (dump_counters, false,"Dump counters on exit") DEFINE_string(map_counters
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator Stack
alingment in bytes in print
stack trace when throwing
exceptions randomize hashes to
avoid predictable hash Fixed
seed to use to hash property
activate a timer that switches
between V8 threads
testing_bool_flag float flag
Seed used for threading test
randomness A filename with
extra code to be included in
the Print usage including on
console Map counters to a file 		DEFINE_args (js_arguments, JSARGUMENTS_INIT,"Pass all remaining arguments to the script. Alias for \"--\".") DEFINE_bool(debug_compile_events
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator Stack
alingment in bytes in print
stack trace when throwing
exceptions randomize hashes to
avoid predictable hash Fixed
seed to use to hash property
activate a timer that switches
between V8 threads
testing_bool_flag float flag
Seed used for threading test
randomness A filename with
extra code to be included in
the Print usage including on
console Map counters to a file
Enable debugger compile events 		DEFINE_bool (debug_script_collected_events, true,"Enable debugger script collected events") DEFINE_bool(gdbjit
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator Stack
alingment in bytes in print
stack trace when throwing
exceptions randomize hashes to
avoid predictable hash Fixed
seed to use to hash property
activate a timer that switches
between V8 threads
testing_bool_flag float flag
Seed used for threading test
randomness A filename with
extra code to be included in
the Print usage including on
console Map counters to a file
Enable debugger compile events
enable GDBJIT 		interface (disables compacting GC)") DEFINE_bool(gdbjit_full
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator Stack
alingment in bytes in print
stack trace when throwing
exceptions randomize hashes to
avoid predictable hash Fixed
seed to use to hash property
activate a timer that switches
between V8 threads
testing_bool_flag float flag
Seed used for threading test
randomness A filename with
extra code to be included in
the Print usage including on
console Map counters to a file
Enable debugger compile events
enable GDBJIT enable GDBJIT
interface for all code objects 		DEFINE_bool (gdbjit_dump, false,"dump elf objects with debug info to disk") DEFINE_string(gdbjit_dump_filter
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator Stack
alingment in bytes in print
stack trace when throwing
exceptions randomize hashes to
avoid predictable hash Fixed
seed to use to hash property
activate a timer that switches
between V8 threads
testing_bool_flag float flag
Seed used for threading test
randomness A filename with
extra code to be included in
the Print usage including on
console Map counters to a file
Enable debugger compile events
enable GDBJIT enable GDBJIT
interface for all code objects
dump only objects containing
this substring 		DEFINE_bool (force_marking_deque_overflows, false,"force overflows of marking deque by reducing it's size ""to 64 words") DEFINE_bool(stress_compaction
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator Stack
alingment in bytes in print
stack trace when throwing
exceptions randomize hashes to
avoid predictable hash Fixed
seed to use to hash property
activate a timer that switches
between V8 threads
testing_bool_flag float flag
Seed used for threading test
randomness A filename with
extra code to be included in
the Print usage including on
console Map counters to a file
Enable debugger compile events
enable GDBJIT enable GDBJIT
interface for all code objects
dump only objects containing
this substring stress the GC
compactor to flush out 		bugs (implies" "--force_marking_deque_overflows)") DEFINE_bool(enable_slow_asserts
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator Stack
alingment in bytes in print
stack trace when throwing
exceptions randomize hashes to
avoid predictable hash Fixed
seed to use to hash property
activate a timer that switches
between V8 threads
testing_bool_flag float flag
Seed used for threading test
randomness A filename with
extra code to be included in
the Print usage including on
console Map counters to a file
Enable debugger compile events
enable GDBJIT enable GDBJIT
interface for all code objects
dump only objects containing
this substring stress the GC
compactor to flush out enable
asserts that are slow to
execute 		DEFINE_bool (trace_codegen, false,"print name of functions for which code is generated") DEFINE_bool(print_source
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator Stack
alingment in bytes in print
stack trace when throwing
exceptions randomize hashes to
avoid predictable hash Fixed
seed to use to hash property
activate a timer that switches
between V8 threads
testing_bool_flag float flag
Seed used for threading test
randomness A filename with
extra code to be included in
the Print usage including on
console Map counters to a file
Enable debugger compile events
enable GDBJIT enable GDBJIT
interface for all code objects
dump only objects containing
this substring stress the GC
compactor to flush out enable
asserts that are slow to
execute pretty print source
code 		DEFINE_bool (print_builtin_source, false,"pretty print source code for builtins") DEFINE_bool(print_ast
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator Stack
alingment in bytes in print
stack trace when throwing
exceptions randomize hashes to
avoid predictable hash Fixed
seed to use to hash property
activate a timer that switches
between V8 threads
testing_bool_flag float flag
Seed used for threading test
randomness A filename with
extra code to be included in
the Print usage including on
console Map counters to a file
Enable debugger compile events
enable GDBJIT enable GDBJIT
interface for all code objects
dump only objects containing
this substring stress the GC
compactor to flush out enable
asserts that are slow to
execute pretty print source
code print source AST 		DEFINE_bool (print_builtin_ast, false,"print source AST for builtins") DEFINE_string(stop_at
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator Stack
alingment in bytes in print
stack trace when throwing
exceptions randomize hashes to
avoid predictable hash Fixed
seed to use to hash property
activate a timer that switches
between V8 threads
testing_bool_flag float flag
Seed used for threading test
randomness A filename with
extra code to be included in
the Print usage including on
console Map counters to a file
Enable debugger compile events
enable GDBJIT enable GDBJIT
interface for all code objects
dump only objects containing
this substring stress the GC
compactor to flush out enable
asserts that are slow to
execute pretty print source
code print source AST function
name where to insert a
breakpoint 		DEFINE_bool (print_builtin_scopes, false,"print scopes for builtins") DEFINE_bool(print_scopes
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator Stack
alingment in bytes in print
stack trace when throwing
exceptions randomize hashes to
avoid predictable hash Fixed
seed to use to hash property
activate a timer that switches
between V8 threads
testing_bool_flag float flag
Seed used for threading test
randomness A filename with
extra code to be included in
the Print usage including on
console Map counters to a file
Enable debugger compile events
enable GDBJIT enable GDBJIT
interface for all code objects
dump only objects containing
this substring stress the GC
compactor to flush out enable
asserts that are slow to
execute pretty print source
code print source AST function
name where to insert a
breakpoint print scopes 		DEFINE_bool (trace_contexts, false,"trace contexts operations") DEFINE_bool(gc_greedy
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator Stack
alingment in bytes in print
stack trace when throwing
exceptions randomize hashes to
avoid predictable hash Fixed
seed to use to hash property
activate a timer that switches
between V8 threads
testing_bool_flag float flag
Seed used for threading test
randomness A filename with
extra code to be included in
the Print usage including on
console Map counters to a file
Enable debugger compile events
enable GDBJIT enable GDBJIT
interface for all code objects
dump only objects containing
this substring stress the GC
compactor to flush out enable
asserts that are slow to
execute pretty print source
code print source AST function
name where to insert a
breakpoint print scopes
perform GC prior to some
allocations 		DEFINE_bool (gc_verbose, false,"print stuff during garbage collection") DEFINE_bool(heap_stats
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator Stack
alingment in bytes in print
stack trace when throwing
exceptions randomize hashes to
avoid predictable hash Fixed
seed to use to hash property
activate a timer that switches
between V8 threads
testing_bool_flag float flag
Seed used for threading test
randomness A filename with
extra code to be included in
the Print usage including on
console Map counters to a file
Enable debugger compile events
enable GDBJIT enable GDBJIT
interface for all code objects
dump only objects containing
this substring stress the GC
compactor to flush out enable
asserts that are slow to
execute pretty print source
code print source AST function
name where to insert a
breakpoint print scopes
perform GC prior to some
allocations report heap
statistics before and after GC 		DEFINE_bool (code_stats, false,"report code statistics after GC") DEFINE_bool(verify_native_context_separation
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator Stack
alingment in bytes in print
stack trace when throwing
exceptions randomize hashes to
avoid predictable hash Fixed
seed to use to hash property
activate a timer that switches
between V8 threads
testing_bool_flag float flag
Seed used for threading test
randomness A filename with
extra code to be included in
the Print usage including on
console Map counters to a file
Enable debugger compile events
enable GDBJIT enable GDBJIT
interface for all code objects
dump only objects containing
this substring stress the GC
compactor to flush out enable
asserts that are slow to
execute pretty print source
code print source AST function
name where to insert a
breakpoint print scopes
perform GC prior to some
allocations report heap
statistics before and after GC
verify that code holds on to
at most one native context
after GC 		DEFINE_bool (print_handles, false,"report handles after GC") DEFINE_bool(print_global_handles
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator Stack
alingment in bytes in print
stack trace when throwing
exceptions randomize hashes to
avoid predictable hash Fixed
seed to use to hash property
activate a timer that switches
between V8 threads
testing_bool_flag float flag
Seed used for threading test
randomness A filename with
extra code to be included in
the Print usage including on
console Map counters to a file
Enable debugger compile events
enable GDBJIT enable GDBJIT
interface for all code objects
dump only objects containing
this substring stress the GC
compactor to flush out enable
asserts that are slow to
execute pretty print source
code print source AST function
name where to insert a
breakpoint print scopes
perform GC prior to some
allocations report heap
statistics before and after GC
verify that code holds on to
at most one native context
after GC report global handles
after GC 		DEFINE_bool (trace_ic, false,"trace inline cache state transitions") DEFINE_bool(print_interfaces
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator Stack
alingment in bytes in print
stack trace when throwing
exceptions randomize hashes to
avoid predictable hash Fixed
seed to use to hash property
activate a timer that switches
between V8 threads
testing_bool_flag float flag
Seed used for threading test
randomness A filename with
extra code to be included in
the Print usage including on
console Map counters to a file
Enable debugger compile events
enable GDBJIT enable GDBJIT
interface for all code objects
dump only objects containing
this substring stress the GC
compactor to flush out enable
asserts that are slow to
execute pretty print source
code print source AST function
name where to insert a
breakpoint print scopes
perform GC prior to some
allocations report heap
statistics before and after GC
verify that code holds on to
at most one native context
after GC report global handles
after GC print interfaces 		DEFINE_bool (print_interface_details, false,"print interface inference details") DEFINE_int(print_interface_depth
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator Stack
alingment in bytes in print
stack trace when throwing
exceptions randomize hashes to
avoid predictable hash Fixed
seed to use to hash property
activate a timer that switches
between V8 threads
testing_bool_flag float flag
Seed used for threading test
randomness A filename with
extra code to be included in
the Print usage including on
console Map counters to a file
Enable debugger compile events
enable GDBJIT enable GDBJIT
interface for all code objects
dump only objects containing
this substring stress the GC
compactor to flush out enable
asserts that are slow to
execute pretty print source
code print source AST function
name where to insert a
breakpoint print scopes
perform GC prior to some
allocations report heap
statistics before and after GC
verify that code holds on to
at most one native context
after GC report global handles
after GC print interfaces
depth for printing interfaces 		DEFINE_bool (trace_normalization, false,"prints when objects are turned into dictionaries.") DEFINE_bool(trace_lazy
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator Stack
alingment in bytes in print
stack trace when throwing
exceptions randomize hashes to
avoid predictable hash Fixed
seed to use to hash property
activate a timer that switches
between V8 threads
testing_bool_flag float flag
Seed used for threading test
randomness A filename with
extra code to be included in
the Print usage including on
console Map counters to a file
Enable debugger compile events
enable GDBJIT enable GDBJIT
interface for all code objects
dump only objects containing
this substring stress the GC
compactor to flush out enable
asserts that are slow to
execute pretty print source
code print source AST function
name where to insert a
breakpoint print scopes
perform GC prior to some
allocations report heap
statistics before and after GC
verify that code holds on to
at most one native context
after GC report global handles
after GC print interfaces
depth for printing interfaces
trace lazy compilation 		DEFINE_bool (collect_heap_spill_statistics, false,"report heap spill statistics along with heap_stats ""(requires heap_stats)") DEFINE_bool(trace_isolates
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator Stack
alingment in bytes in print
stack trace when throwing
exceptions randomize hashes to
avoid predictable hash Fixed
seed to use to hash property
activate a timer that switches
between V8 threads
testing_bool_flag float flag
Seed used for threading test
randomness A filename with
extra code to be included in
the Print usage including on
console Map counters to a file
Enable debugger compile events
enable GDBJIT enable GDBJIT
interface for all code objects
dump only objects containing
this substring stress the GC
compactor to flush out enable
asserts that are slow to
execute pretty print source
code print source AST function
name where to insert a
breakpoint print scopes
perform GC prior to some
allocations report heap
statistics before and after GC
verify that code holds on to
at most one native context
after GC report global handles
after GC print interfaces
depth for printing interfaces
trace lazy compilation trace
isolate state changes 		DEFINE_bool (log_state_changes, false,"Log state changes.") DEFINE_bool(regexp_possessive_quantifier
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator Stack
alingment in bytes in print
stack trace when throwing
exceptions randomize hashes to
avoid predictable hash Fixed
seed to use to hash property
activate a timer that switches
between V8 threads
testing_bool_flag float flag
Seed used for threading test
randomness A filename with
extra code to be included in
the Print usage including on
console Map counters to a file
Enable debugger compile events
enable GDBJIT enable GDBJIT
interface for all code objects
dump only objects containing
this substring stress the GC
compactor to flush out enable
asserts that are slow to
execute pretty print source
code print source AST function
name where to insert a
breakpoint print scopes
perform GC prior to some
allocations report heap
statistics before and after GC
verify that code holds on to
at most one native context
after GC report global handles
after GC print interfaces
depth for printing interfaces
trace lazy compilation trace
isolate state changes enable
possessive quantifier syntax
for testing 		DEFINE_bool (trace_regexp_bytecodes, false,"trace regexp bytecode execution") DEFINE_bool(trace_regexp_assembler
 
 DEFINE_bool (log, false,"Minimal logging (no API, code, GC, suspect, or handles samples).") DEFINE_bool(log_all
 
Log all events to the log file DEFINE_bool (log_runtime, false,"Activate runtime system %Log call.") DEFINE_bool(log_api
 
Log all events to the log file
Log API events to the log file 		DEFINE_bool (log_code, false,"Log code events to the log file without profiling.") DEFINE_bool(log_gc
 
Log all events to the log file
Log API events to the log file
Log heap samples on garbage
collection for the hp2ps tool 		DEFINE_bool (log_handles, false,"Log global handle events.") DEFINE_bool(log_snapshot_positions
 
Log all events to the log file
Log API events to the log file
Log heap samples on garbage
collection for the hp2ps tool
log positions 		of (de) serialized objects in the snapshot.") DEFINE_bool(log_suspect
 
Log all events to the log file
Log API events to the log file
Log heap samples on garbage
collection for the hp2ps tool
log positions Log suspect
operations 		DEFINE_bool (prof, false,"Log statistical profiling information (implies --log-code).") DEFINE_bool(prof_auto
 
Log all events to the log file
Log API events to the log file
Log heap samples on garbage
collection for the hp2ps tool
log positions Log suspect
operations Used with starts
profiling automatically 		DEFINE_bool (prof_lazy, false,"Used with --prof, only does sampling and logging"" when profiler is active (implies --noprof_auto).") DEFINE_bool(prof_browser_mode
 
Log all events to the log file
Log API events to the log file
Log heap samples on garbage
collection for the hp2ps tool
log positions Log suspect
operations Used with starts
profiling automatically Used
with turns on browser
compatible mode for profiling 		DEFINE_bool (log_regexp, false,"Log regular expression execution.") DEFINE_bool(sliding_state_window
 
Log all events to the log file
Log API events to the log file
Log heap samples on garbage
collection for the hp2ps tool
log positions Log suspect
operations Used with starts
profiling automatically Used
with turns on browser
compatible mode for profiling
Update sliding state window
counters 		DEFINE_string (logfile,"v8.log","Specify the name of the log file.") DEFINE_bool(ll_prof
 
Log all events to the log file
Log API events to the log file
Log heap samples on garbage
collection for the hp2ps tool
log positions Log suspect
operations Used with starts
profiling automatically Used
with turns on browser
compatible mode for profiling
Update sliding state window
counters Enable low level
linux profiler 		DEFINE_string (gc_fake_mmap,"/tmp/__v8_gc__","Specify the name of the file for fake gc mmap used in ll_prof") DEFINE_bool(trace_elements_transitions
 
Log all events to the log file
Log API events to the log file
Log heap samples on garbage
collection for the hp2ps tool
log positions Log suspect
operations Used with starts
profiling automatically Used
with turns on browser
compatible mode for profiling
Update sliding state window
counters Enable low level
linux profiler trace elements
transitions 		DEFINE_bool (print_code_stubs, false,"print code stubs") DEFINE_bool(test_secondary_stub_cache
 
Log all events to the log file
Log API events to the log file
Log heap samples on garbage
collection for the hp2ps tool
log positions Log suspect
operations Used with starts
profiling automatically Used
with turns on browser
compatible mode for profiling
Update sliding state window
counters Enable low level
linux profiler trace elements
transitions test secondary
stub cache by disabling the
primary one 		DEFINE_bool (test_primary_stub_cache, false,"test primary stub cache by disabling the secondary one") DEFINE_bool(print_code
 
Log all events to the log file
Log API events to the log file
Log heap samples on garbage
collection for the hp2ps tool
log positions Log suspect
operations Used with starts
profiling automatically Used
with turns on browser
compatible mode for profiling
Update sliding state window
counters Enable low level
linux profiler trace elements
transitions test secondary
stub cache by disabling the
primary one print generated
code 		DEFINE_bool (print_opt_code, false,"print optimized code") DEFINE_bool(print_unopt_code
 
Log all events to the log file
Log API events to the log file
Log heap samples on garbage
collection for the hp2ps tool
log positions Log suspect
operations Used with starts
profiling automatically Used
with turns on browser
compatible mode for profiling
Update sliding state window
counters Enable low level
linux profiler trace elements
transitions test secondary
stub cache by disabling the
primary one print generated
code print unoptimized code
before printing optimized code
based on it 		DEFINE_bool (print_code_verbose, false,"print more information for code") DEFINE_bool(print_builtin_code
 

Variables

 true
 
activate correct semantics for
inheriting readonliness 		false
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen 		Z
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if 		NULL
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator Stack
alingment in bytes in print
stack trace when throwing
exceptions randomize hashes to
avoid predictable hash Fixed
seed to use to hash property
activate a timer that switches
between V8 threads
testing_bool_flag float flag
Seed used for threading test
randomness A filename with
extra code to be included in
the Print usage 		message
 
activate correct semantics for
inheriting readonliness enable
harmony semantics for typeof
enable harmony enable harmony
proxies enable all harmony
harmony_scoping
harmony_proxies
harmony_scoping tracks arrays
with only smi values
automatically unbox arrays of
doubles use crankshaft use
hydrogen range analysis use
hydrogen global value
numbering use function
inlining maximum number of AST
nodes considered for a single
inlining loop invariant code
motion print statistics for
hydrogen trace generated IR
for specified phases trace
register allocator trace range
analysis trace representation
types environment for every
instruction put a break point
before deoptimizing
polymorphic inlining perform
array bounds checks
elimination use dead code
elimination trace on stack
replacement optimize closures
cache optimized code for
closures functions with
arguments object loop weight
for representation inference
allow uint32 values on
optimize frames if they are
used only in safe operations
track parallel recompilation
enable all profiler
experiments number of stack
frames inspected by the
profiler call recompile stub
directly when self optimizing
trigger profiler ticks based
on counting instead of timing
weight back edges by jump
distance for interrupt
triggering percentage of ICs
that must have type info to
allow optimization
watch_ic_patching
retry_self_opt
interrupt_at_exit extra
verbose compilation tracing
generate extra emit comments
in code disassembly enable use
of SSE3 instructions if
available enable use of CMOV
instruction if available
enable use of SAHF instruction
if enable use of VFP3
instructions if available this
implies enabling ARMv7 and
VFP2 enable use of VFP2
instructions if available
enable use of SDIV and UDIV
instructions if enable loading
bit constant by means of movw
movt instruction enable
unaligned accesses for enable
use of MIPS FPU instructions
if expose natives in global
object expose gc extension
number of stack frames to
capture disable builtin
natives files print a stack
trace if an assertion failure
occurs use random jit cookie
to mask large constants trace
lazy optimization use adaptive
optimizations prepare for
turning on always opt minimum
length for automatic enable
preparsing maximum number of
optimization attempts before
giving up cache prototype
transitions automatically set
the debug break flag when
debugger commands are in the
queue always cause a debug
break before aborting maximum
length of function source code
printed in a stack trace max
size of the new max size of
the old max size of executable
always perform global GCs
print one trace line following
each garbage collection do not
print trace line after
scavenger collection print
more details following each
garbage collection print
amount of external allocated
memory after each time it is
adjusted flush code that we
expect not to use again before
full gc do incremental marking
steps track object counts and
memory usage use caching
Perform compaction on every
full GC Never perform
compaction on full GC testing
only Compact code space on
full incremental collections
Default seed for initializing
random allows verbose printing
trace parsing and preparsing
Check icache flushes in ARM
and MIPS simulator Stack
alingment in bytes in print
stack trace when throwing
exceptions randomize hashes to
avoid predictable hash Fixed
seed to use to hash property
activate a timer that switches
between V8 threads
testing_bool_flag float flag
Seed used for threading test
randomness A filename with
extra code to be included in
the Print usage including 		flags
 
Log all events to the log file
Log API events to the log file
Log heap samples on garbage
collection for the hp2ps tool
log positions Log suspect
operations Used with 		prof
 

Macro Definition Documentation

#define DEFINE_args (   nam,
  def,
  cmt 
)    FLAG(ARGS, JSArguments, nam, def, cmt)

Definition at line 127 of file flags.h.

#define DEFINE_args (   nam,
  def,
  cmt 
)    FLAG(ARGS, JSArguments, nam, def, cmt)
#define DEFINE_args (   nam,
  def,
  cmt 
)    FLAG(ARGS, JSArguments, nam, def, cmt)
#define DEFINE_args (   nam,
  def,
  cmt 
)    FLAG(ARGS, JSArguments, nam, def, cmt)
#define DEFINE_args (   nam,
  def,
  cmt 
)    FLAG(ARGS, JSArguments, nam, def, cmt)
#define DEFINE_args (   nam,
  def,
  cmt 
)    FLAG(ARGS, JSArguments, nam, def, cmt)
#define DEFINE_bool (   nam,
  def,
  cmt 
)    FLAG(BOOL, bool, nam, def, cmt)

Definition at line 123 of file flags.h.

#define DEFINE_bool (   nam,
  def,
  cmt 
)    FLAG(BOOL, bool, nam, def, cmt)
#define DEFINE_bool (   nam,
  def,
  cmt 
)    FLAG(BOOL, bool, nam, def, cmt)
#define DEFINE_bool (   nam,
  def,
  cmt 
)    FLAG(BOOL, bool, nam, def, cmt)
#define DEFINE_bool (   nam,
  def,
  cmt 
)    FLAG(BOOL, bool, nam, def, cmt)
#define DEFINE_bool (   nam,
  def,
  cmt 
)    FLAG(BOOL, bool, nam, def, cmt)
#define DEFINE_float (   nam,
  def,
  cmt 
)    FLAG(FLOAT, double, nam, def, cmt)
#define DEFINE_float (   nam,
  def,
  cmt 
)    FLAG(FLOAT, double, nam, def, cmt)
#define DEFINE_float (   nam,
  def,
  cmt 
)    FLAG(FLOAT, double, nam, def, cmt)

Definition at line 125 of file flags.h.

#define DEFINE_float (   nam,
  def,
  cmt 
)    FLAG(FLOAT, double, nam, def, cmt)
#define DEFINE_float (   nam,
  def,
  cmt 
)    FLAG(FLOAT, double, nam, def, cmt)
#define DEFINE_float (   nam,
  def,
  cmt 
)    FLAG(FLOAT, double, nam, def, cmt)
#define DEFINE_implication (   whenflag,
  thenflag 
)
#define DEFINE_implication (   whenflag,
  thenflag 
)
#define DEFINE_implication (   whenflag,
  thenflag 
)
#define DEFINE_implication (   whenflag,
  thenflag 
)
#define DEFINE_implication (   whenflag,
  thenflag 
)    if (FLAG_##whenflag) FLAG_##thenflag = true;
#define DEFINE_int (   nam,
  def,
  cmt 
)    FLAG(INT, int, nam, def, cmt)
#define DEFINE_int (   nam,
  def,
  cmt 
)    FLAG(INT, int, nam, def, cmt)

Definition at line 124 of file flags.h.

#define DEFINE_int (   nam,
  def,
  cmt 
)    FLAG(INT, int, nam, def, cmt)
#define DEFINE_int (   nam,
  def,
  cmt 
)    FLAG(INT, int, nam, def, cmt)
#define DEFINE_int (   nam,
  def,
  cmt 
)    FLAG(INT, int, nam, def, cmt)
#define DEFINE_int (   nam,
  def,
  cmt 
)    FLAG(INT, int, nam, def, cmt)
#define DEFINE_string (   nam,
  def,
  cmt 
)    FLAG(STRING, const char*, nam, def, cmt)
#define DEFINE_string (   nam,
  def,
  cmt 
)    FLAG(STRING, const char*, nam, def, cmt)

Definition at line 126 of file flags.h.

#define DEFINE_string (   nam,
  def,
  cmt 
)    FLAG(STRING, const char*, nam, def, cmt)
#define DEFINE_string (   nam,
  def,
  cmt 
)    FLAG(STRING, const char*, nam, def, cmt)
#define DEFINE_string (   nam,
  def,
  cmt 
)    FLAG(STRING, const char*, nam, def, cmt)
#define DEFINE_string (   nam,
  def,
  cmt 
)    FLAG(STRING, const char*, nam, def, cmt)
#define FLAG   FLAG_FULL
#define FLAG   FLAG_FULL
#define FLAG   FLAG_FULL
#define FLAG   FLAG_FULL

Definition at line 620 of file flags.h.

#define FLAG   FLAG_FULL
#define FLAG   FLAG_FULL
#define FLAG   FLAG_READONLY
#define FLAG   FLAG_READONLY
#define FLAG   FLAG_READONLY
#define FLAG   FLAG_READONLY
#define FLAG   FLAG_READONLY

Definition at line 620 of file flags.h.

#define FLAG   FLAG_READONLY
#define FLAG   FLAG_FULL
#define FLAG   FLAG_FULL
#define FLAG   FLAG_FULL
#define FLAG   FLAG_FULL
#define FLAG   FLAG_FULL
#define FLAG   FLAG_FULL

Definition at line 620 of file flags.h.

#define FLAG   FLAG_READONLY
#define FLAG   FLAG_READONLY
#define FLAG   FLAG_READONLY

Definition at line 620 of file flags.h.

#define FLAG   FLAG_READONLY
#define FLAG   FLAG_READONLY
#define FLAG   FLAG_READONLY
#define FLAG_FULL (   ftype,
  ctype,
  nam,
  def,
  cmt 
)    extern ctype FLAG_##nam;
#define FLAG_FULL (   ftype,
  ctype,
  nam,
  def,
  cmt 
)    ctype FLAG_##nam = def;
#define FLAG_FULL (   ftype,
  ctype,
  nam,
  def,
  cmt 
)    static ctype const FLAGDEFAULT_##nam = def;
#define FLAG_FULL (   ftype,
  ctype,
  nam,
  def,
  cmt 
)    { Flag::TYPE_##ftype, #nam, &FLAG_##nam, &FLAGDEFAULT_##nam, cmt, false },
#define FLAG_FULL (   ftype,
  ctype,
  nam,
  def,
  cmt 
)
#define FLAG_READONLY (   ftype,
  ctype,
  nam,
  def,
  cmt 
)    static ctype const FLAG_##nam = def;
#define FLAG_READONLY (   ftype,
  ctype,
  nam,
  def,
  cmt 
)
#define FLAG_READONLY (   ftype,
  ctype,
  nam,
  def,
  cmt 
)
#define FLAG_READONLY (   ftype,
  ctype,
  nam,
  def,
  cmt 
)
#define FLAG_READONLY (   ftype,
  ctype,
  nam,
  def,
  cmt 
)
#define JSARGUMENTS_INIT   {{}}

Definition at line 85 of file flags.h.

Function Documentation

activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for ARMv7 ( ARM  only)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if available ( X64  only)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if available ( ARM  only)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if available ( MIPS  only)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag float flag Seed used for threading test randomness A filename with extra code to be included in the Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out bugs ( implies" "--  force_marking_deque_overflows)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra code ( assertions  )

Referenced by StubCache::ComputeCallArguments(), StubCache::ComputeCallConstant(), StubCache::ComputeCallField(), StubCache::ComputeCallGlobal(), StubCache::ComputeCallInterceptor(), StubCache::ComputeCallMegamorphic(), StubCache::ComputeCallMiss(), StubCache::ComputeCallNormal(), StubCache::ComputeCallPreMonomorphic(), StubCache::ComputeKeyedLoadArrayLength(), StubCache::ComputeKeyedLoadCallback(), StubCache::ComputeKeyedLoadConstant(), StubCache::ComputeKeyedLoadField(), StubCache::ComputeKeyedLoadFunctionPrototype(), StubCache::ComputeKeyedLoadInterceptor(), StubCache::ComputeKeyedLoadOrStoreElement(), StubCache::ComputeKeyedLoadStringLength(), StubCache::ComputeKeyedStoreField(), StubCache::ComputeLoadCallback(), StubCache::ComputeLoadConstant(), StubCache::ComputeLoadField(), StubCache::ComputeLoadGlobal(), StubCache::ComputeLoadInterceptor(), StubCache::ComputeLoadNonexistent(), StubCache::ComputeLoadViaGetter(), StubCache::ComputeStoreCallback(), StubCache::ComputeStoreField(), StubCache::ComputeStoreGlobal(), StubCache::ComputeStoreInterceptor(), StubCache::ComputeStoreViaSetter(), StubCache::FindCallInitialize(), CodeGenerator::MakeCodeEpilogue(), StubCache::Set(), Builtins::SetUp(), and TEST().

activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash collisions ( with snapshots this option cannot override the baked-in  seed)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag float flag Seed used for threading test randomness A filename with extra code to be included in the Print usage including on console Map counters to a file DEFINE_args ( js_arguments  ,
JSARGUMENTS_INIT  ,
"Pass all remaining arguments to the script. Alias for \"--\"."   
)
DEFINE_bool ( use_strict  ,
false  ,
"enforce strict mode"   
)
activate correct semantics for inheriting readonliness DEFINE_bool ( es52_globals  ,
true  ,
"activate new semantics for global var declarations"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof DEFINE_bool ( harmony_scoping  ,
false  ,
"enable harmony block scoping"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies DEFINE_bool ( harmony_collections  ,
false  ,
"enable harmony collections (sets, maps, and weak maps)"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping DEFINE_bool ( packed_arrays  ,
true  ,
"optimizes arrays that have no holes"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values DEFINE_bool ( clever_optimizations  ,
true  ,
"Optimize object  size,
Array  shift,
DOM strings and string+"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles DEFINE_bool ( string_slices  ,
true  ,
"use string slices"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis DEFINE_bool ( eliminate_dead_phis  ,
true  ,
"eliminate dead phis"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering DEFINE_bool ( use_canonicalizing  ,
true  ,
"use hydrogen instruction canonicalizing"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion DEFINE_bool ( collect_megamorphic_maps_from_stub_cache  ,
true  ,
"crankshaft harvests type feedback from stub cache"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen DEFINE_bool ( trace_hydrogen  ,
false  ,
"trace generated hydrogen to file"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases DEFINE_bool ( trace_inlining  ,
false  ,
"trace inlining decisions"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator DEFINE_bool ( trace_all_uses  ,
false  ,
"trace all use positions"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis DEFINE_bool ( trace_gvn  ,
false  ,
"trace global value numbering"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types DEFINE_bool ( stress_pointer_maps  ,
false  ,
"pointer map for every instruction"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing DEFINE_bool ( deoptimize_uncommon_cases  ,
true  ,
"deoptimize uncommon cases"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining DEFINE_bool ( use_osr  ,
true  ,
"use on-stack replacement"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination DEFINE_bool ( array_index_dehoisting  ,
true  ,
"perform array index dehoisting"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination DEFINE_bool ( trace_dead_code_elimination  ,
false  ,
"trace dead code elimination"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures DEFINE_bool ( lookup_sample_by_shared  ,
true  ,
"when picking a function to  optimize,
watch for shared function" "  info,
not JSFunction itself"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures DEFINE_bool ( inline_construct  ,
true  ,
"inline constructor calls"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object DEFINE_bool ( inline_accessors  ,
true  ,
"inline JavaScript accessors"   
)
inline
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference DEFINE_bool ( optimize_for_in  ,
true  ,
"optimize functions containing for-in loops"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations DEFINE_bool ( parallel_recompilation  ,
false  ,
"optimizing hot functions asynchronously on a separate thread"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments DEFINE_bool ( watch_ic_patching  ,
false  ,
"profiler considers IC stability"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler DEFINE_bool ( self_optimization  ,
false  ,
"primitive functions trigger their own optimization"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing DEFINE_bool ( retry_self_opt  ,
false  ,
"re-try self-optimization if it failed"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing DEFINE_bool ( interrupt_at_exit  ,
false  ,
"insert an interrupt check at function exit"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly DEFINE_bool ( enable_sse2  ,
true  ,
"enable use of SSE2 instructions if available"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available DEFINE_bool ( enable_sse4_1  ,
true  ,
"enable use of SSE4.1 instructions if available"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available DEFINE_bool ( enable_rdtsc  ,
true  ,
"enable use of RDTSC instruction if available"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available DEFINE_bool ( enable_armv7  ,
true  ,
"enable use of ARMv7 instructions if available (ARM only)"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension DEFINE_bool ( expose_externalize_string  ,
false  ,
"expose externalize string extension"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture DEFINE_bool ( builtins_in_stack_traces  ,
false  ,
"show built-in functions in stack traces"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files DEFINE_bool ( inline_new  ,
true  ,
"use fast inline allocation"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs DEFINE_bool ( trace  ,
false  ,
"trace function calls"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants DEFINE_bool ( lazy  ,
true  ,
"use lazy compilation"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization DEFINE_bool ( trace_opt_stats  ,
false  ,
"trace lazy optimization statistics"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations DEFINE_bool ( always_opt  ,
false  ,
"always try to optimize functions"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt DEFINE_bool ( trace_deopt  ,
false  ,
"trace deoptimization"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing DEFINE_bool ( always_full_compiler  ,
false  ,
"try to use the dedicated run-once backend for all code"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up DEFINE_bool ( compilation_cache  ,
true  ,
"enable compilation cache"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions DEFINE_bool ( trace_debug_json  ,
false  ,
"trace debugging JSON request/response"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue DEFINE_bool ( enable_liveedit  ,
true  ,
"enable liveedit experimental feature"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace DEFINE_bool ( always_inline_smi_code  ,
false  ,
"always inline smi code in non-opt code"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection DEFINE_bool ( trace_gc_nvp  ,
false   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection DEFINE_bool ( print_cumulative_gc_stat  ,
false   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection DEFINE_bool ( trace_fragmentation  ,
false  ,
"report fragmentation for old pointer and data pages"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted DEFINE_bool ( collect_maps  ,
true  ,
"garbage collect maps from which no objects can be reached"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc DEFINE_bool ( incremental_marking  ,
true  ,
"use incremental marking"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps DEFINE_bool ( trace_incremental_marking  ,
false  ,
"trace progress of the incremental marking"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage DEFINE_bool ( use_idle_notification  ,
true  ,
"Use idle notification to reduce memory footprint."   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching DEFINE_bool ( native_code_counters  ,
false  ,
"generate extra code for manipulating stats counters"   
)
inline
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC DEFINE_bool ( lazy_sweeping  ,
true  ,
"Use lazy sweeping for old pointer and data spaces"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only DEFINE_bool ( compact_code_space  ,
true  ,
"Compact code space on full non-incremental collections"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections DEFINE_bool ( cleanup_code_caches_at_gc  ,
true  ,
"Flush inline caches prior to mark compact collection and ""flush code caches in maps during mark compact cycle."   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing DEFINE_bool ( allow_natives_syntax  ,
false  ,
"allow natives syntax"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing DEFINE_bool ( trace_sim  ,
false  ,
"Trace simulator execution"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions DEFINE_bool ( preallocate_message_memory  ,
false  ,
"preallocate some memory to build stack traces."   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads DEFINE_bool ( regexp_optimization  ,
true  ,
"generate optimized regexp code"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag float flag Seed used for threading test randomness A filename with extra code to be included in the Print usage including on console DEFINE_bool ( dump_counters  ,
false  ,
"Dump counters on exit"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag float flag Seed used for threading test randomness A filename with extra code to be included in the Print usage including on console Map counters to a file Enable debugger compile events DEFINE_bool ( debug_script_collected_events  ,
true  ,
"Enable debugger script collected events"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag float flag Seed used for threading test randomness A filename with extra code to be included in the Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects DEFINE_bool ( gdbjit_dump  ,
false  ,
"dump elf objects with debug info to disk"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag float flag Seed used for threading test randomness A filename with extra code to be included in the Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring DEFINE_bool ( force_marking_deque_overflows  ,
false  ,
"force overflows of marking deque by reducing it's size ""to 64 words"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag float flag Seed used for threading test randomness A filename with extra code to be included in the Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out enable asserts that are slow to execute DEFINE_bool ( trace_codegen  ,
false  ,
"print name of functions for which code is generated"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag float flag Seed used for threading test randomness A filename with extra code to be included in the Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out enable asserts that are slow to execute pretty print source code DEFINE_bool ( print_builtin_source  ,
false  ,
"pretty print source code for builtins"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag float flag Seed used for threading test randomness A filename with extra code to be included in the Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out enable asserts that are slow to execute pretty print source code print source AST DEFINE_bool ( print_builtin_ast  ,
false  ,
"print source AST for builtins"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag float flag Seed used for threading test randomness A filename with extra code to be included in the Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out enable asserts that are slow to execute pretty print source code print source AST function name where to insert a breakpoint DEFINE_bool ( print_builtin_scopes  ,
false  ,
"print scopes for builtins"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag float flag Seed used for threading test randomness A filename with extra code to be included in the Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out enable asserts that are slow to execute pretty print source code print source AST function name where to insert a breakpoint print scopes DEFINE_bool ( trace_contexts  ,
false  ,
"trace contexts operations"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag float flag Seed used for threading test randomness A filename with extra code to be included in the Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out enable asserts that are slow to execute pretty print source code print source AST function name where to insert a breakpoint print scopes perform GC prior to some allocations DEFINE_bool ( gc_verbose  ,
false  ,
"print stuff during garbage collection"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag float flag Seed used for threading test randomness A filename with extra code to be included in the Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out enable asserts that are slow to execute pretty print source code print source AST function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC DEFINE_bool ( code_stats  ,
false  ,
"report code statistics after GC"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag float flag Seed used for threading test randomness A filename with extra code to be included in the Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out enable asserts that are slow to execute pretty print source code print source AST function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC verify that code holds on to at most one native context after GC DEFINE_bool ( print_handles  ,
false  ,
"report handles after GC"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag float flag Seed used for threading test randomness A filename with extra code to be included in the Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out enable asserts that are slow to execute pretty print source code print source AST function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC verify that code holds on to at most one native context after GC report global handles after GC DEFINE_bool ( trace_ic  ,
false  ,
"trace inline cache state transitions"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag float flag Seed used for threading test randomness A filename with extra code to be included in the Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out enable asserts that are slow to execute pretty print source code print source AST function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC verify that code holds on to at most one native context after GC report global handles after GC print interfaces DEFINE_bool ( print_interface_details  ,
false  ,
"print interface inference details"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag float flag Seed used for threading test randomness A filename with extra code to be included in the Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out enable asserts that are slow to execute pretty print source code print source AST function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC verify that code holds on to at most one native context after GC report global handles after GC print interfaces depth for printing interfaces DEFINE_bool ( trace_normalization  ,
false  ,
"prints when objects are turned into dictionaries."   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag float flag Seed used for threading test randomness A filename with extra code to be included in the Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out enable asserts that are slow to execute pretty print source code print source AST function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC verify that code holds on to at most one native context after GC report global handles after GC print interfaces depth for printing interfaces trace lazy compilation DEFINE_bool ( collect_heap_spill_statistics  ,
false  ,
"report heap spill statistics along with heap_stats ""(requires heap_stats)"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag float flag Seed used for threading test randomness A filename with extra code to be included in the Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out enable asserts that are slow to execute pretty print source code print source AST function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC verify that code holds on to at most one native context after GC report global handles after GC print interfaces depth for printing interfaces trace lazy compilation trace isolate state changes DEFINE_bool ( log_state_changes  ,
false  ,
"Log state changes."   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag float flag Seed used for threading test randomness A filename with extra code to be included in the Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out enable asserts that are slow to execute pretty print source code print source AST function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC verify that code holds on to at most one native context after GC report global handles after GC print interfaces depth for printing interfaces trace lazy compilation trace isolate state changes enable possessive quantifier syntax for testing DEFINE_bool ( trace_regexp_bytecodes  ,
false  ,
"trace regexp bytecode execution"   
)
DEFINE_bool ( log  ,
false  ,
"Minimal logging (no API, code, GC, suspect, or handles samples)."   
)
Log all events to the log file DEFINE_bool ( log_runtime  ,
false  ,
"Activate runtime system %Log call."   
)
Log all events to the log file Log API events to the log file DEFINE_bool ( log_code  ,
false  ,
"Log code events to the log file without profiling."   
)
Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool DEFINE_bool ( log_handles  ,
false  ,
"Log global handle events."   
)
Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations DEFINE_bool ( prof  ,
false  ,
"Log statistical profiling information (implies --log-code)."   
)
Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with starts profiling automatically DEFINE_bool ( prof_lazy  ,
false  ,
"Used with --  prof,
only does sampling and logging" "when profiler is active(implies--noprof_auto)."   
)
Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with starts profiling automatically Used with turns on browser compatible mode for profiling DEFINE_bool ( log_regexp  ,
false  ,
"Log regular expression execution."   
)
Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with starts profiling automatically Used with turns on browser compatible mode for profiling Update sliding state window counters Enable low level linux profiler trace elements transitions DEFINE_bool ( print_code_stubs  ,
false  ,
"print code stubs"   
)
Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with starts profiling automatically Used with turns on browser compatible mode for profiling Update sliding state window counters Enable low level linux profiler trace elements transitions test secondary stub cache by disabling the primary one DEFINE_bool ( test_primary_stub_cache  ,
false  ,
"test primary stub cache by disabling the secondary one"   
)
Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with starts profiling automatically Used with turns on browser compatible mode for profiling Update sliding state window counters Enable low level linux profiler trace elements transitions test secondary stub cache by disabling the primary one print generated code DEFINE_bool ( print_opt_code  ,
false  ,
"print optimized code"   
)
Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with starts profiling automatically Used with turns on browser compatible mode for profiling Update sliding state window counters Enable low level linux profiler trace elements transitions test secondary stub cache by disabling the primary one print generated code print unoptimized code before printing optimized code based on it DEFINE_bool ( print_code_verbose  ,
false  ,
"print more information for code"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping DEFINE_implication ( harmony  ,
harmony_modules   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies DEFINE_implication ( harmony  ,
harmony_collections   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching DEFINE_implication ( experimental_profiler  ,
self_optimization   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt DEFINE_implication ( experimental_profiler  ,
count_based_interrupts   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit DEFINE_implication ( experimental_profiler  ,
weighted_back_edges   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing DEFINE_implication ( trace_opt_verbose  ,
trace_opt   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining DEFINE_int ( max_inlined_source_size  ,
600  ,
"maximum source size in bytes considered for a single inlining"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining DEFINE_int ( max_inlined_nodes_cumulative  ,
196  ,
"maximum cumulative number of AST nodes considered for inlining"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction DEFINE_int ( deopt_every_n_times  ,
0  ,
"deoptimize every n times a deopt point is passed"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement DEFINE_int ( stress_runs  ,
0  ,
"number of stress runs"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation DEFINE_int ( parallel_recompilation_queue_length  ,
2  ,
"the length of the parallel compilation queue"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering DEFINE_int ( interrupt_budget  ,
0x1700  ,
"execution budget before interrupt is triggered"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization DEFINE_int ( self_opt_count  ,
130  ,
"call count before self-optimization"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting DEFINE_int ( stack_size  ,
kPointerSize *  123,
"default size of stack region v8 is allowed to use (in kBytes)"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs DEFINE_int ( gc_interval  ,
-  1,
"garbage collect after <n> allocations"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator DEFINE_int ( stop_sim_at  ,
0  ,
"Simulator stop after x number of instructions"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag DEFINE_int ( testing_int_flag  ,
13  ,
"testing_int_flag"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft DEFINE_string ( hydrogen_filter  ,
""  ,
"optimization filter"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object DEFINE_string ( expose_debug_as  ,
NULL  ,
"expose debug in global object"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag float flag DEFINE_string ( testing_string_flag  ,
"  Hello,
world!"  ,
"string-flag"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag float flag Seed used for threading test randomness DEFINE_string ( testing_serialization_file  ,
"/tmp/serdes"  ,
"file in which to serialize heap"   
)
Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with starts profiling automatically Used with turns on browser compatible mode for profiling Update sliding state window counters DEFINE_string ( logfile  ,
"v8.log"  ,
"Specify the name of the log file."   
)
Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with starts profiling automatically Used with turns on browser compatible mode for profiling Update sliding state window counters Enable low level linux profiler DEFINE_string ( gc_fake_mmap  ,
"/tmp/__v8_gc__"  ,
"Specify the name of the file for fake gc mmap used in ll_prof"   
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony features ( except  typeof)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old generation ( in  kBytes)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random generator ( 0  ,
the  default,
means to use system  random 
)

Referenced by TEST().

activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 instructions ( ARM  only)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag float flag Seed used for threading test randomness A filename with extra code to be included in the Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT interface ( disables compacting  GC)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property keys ( 0 means  random)
override

Referenced by TEST().

activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable memory ( in  Mbytes)

Referenced by Shell::MapCounters().

activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony modules ( implies block  scoping)
Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions of ( de  )
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction pairs ( ARM  only)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in simulator ( 4 or  8,
8 is  default 
)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag float flag Seed used for threading test randomness A filename with extra code to be included in the snapshot ( mksnapshot  only)

Referenced by TEST().

Variable Documentation

Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with starts profiling automatically Used with turns on browser compatible mode for profiling Update sliding state window counters Enable low level linux profiler trace elements transitions test secondary stub cache by disabling the primary one print generated code print unoptimized code before printing optimized code based on it false

Definition at line 140 of file flag-definitions.h.

activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag float flag Seed used for threading test randomness A filename with extra code to be included in the Print usage including flags

Definition at line 494 of file flag-definitions.h.

Referenced by DuplicateFinder::AddNumber(), StubCache::ComputeCallConstant(), StubCache::ComputeCallField(), StubCache::ComputeCallGlobal(), StubCache::ComputeCallInterceptor(), StubCache::ComputeKeyedLoadArrayLength(), StubCache::ComputeKeyedLoadCallback(), StubCache::ComputeKeyedLoadConstant(), StubCache::ComputeKeyedLoadField(), StubCache::ComputeKeyedLoadFunctionPrototype(), StubCache::ComputeKeyedLoadInterceptor(), StubCache::ComputeKeyedLoadOrStoreElement(), StubCache::ComputeKeyedLoadStringLength(), StubCache::ComputeKeyedStoreField(), StubCache::ComputeLoadCallback(), StubCache::ComputeLoadConstant(), StubCache::ComputeLoadField(), StubCache::ComputeLoadGlobal(), StubCache::ComputeLoadInterceptor(), StubCache::ComputeLoadNonexistent(), StubCache::ComputeLoadViaGetter(), StubCache::ComputeStoreCallback(), StubCache::ComputeStoreField(), StubCache::ComputeStoreGlobal(), StubCache::ComputeStoreInterceptor(), StubCache::ComputeStoreViaSetter(), StubCache::FindCallInitialize(), StubCache::Set(), Builtins::SetUp(), TEST(), TestParserSync(), and TestParserSyncWithFlags().

activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag float flag Seed used for threading test randomness A filename with extra code to be included in the Print usage message

Definition at line 494 of file flag-definitions.h.

Referenced by Exception::Error(), Message::GetEndColumn(), Message::GetEndPosition(), Message::GetScriptData(), Message::GetScriptResourceName(), Message::GetStackTrace(), Message::GetStartPosition(), ExecArgs::Init(), main(), TryCatch::Message(), Exception::RangeError(), Exception::ReferenceError(), ReportException(), Shell::ReportException(), StoringErrorCallback(), Exception::SyntaxError(), TEST(), and Exception::TypeError().

activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag float flag Seed used for threading test randomness NULL

Definition at line 300 of file flag-definitions.h.

Referenced by V8::AddCallCompletedCallback(), V8::AdjustAmountOfExternalAllocatedMemory(), AnalyzeStackInNativeCode(), Function::Call(), Shell::ChangeDirectory(), CheckEqualsHelper(), CheckNonEqualsHelper(), checkStackFrame(), StubCache::CollectMatchingMaps(), CppByteSink::CppByteSink(), Shell::CreateEvaluationContext(), CreateShellContext(), Date::DateTimeConfigurationChangeNotification(), V8::Dispose(), ExecArgs::ExecArgs(), Extension::Extension(), ExternalArrayLimitTestHelper(), CpuProfiler::FindProfile(), LineEditor::Get(), String::GetExternalAsciiStringResource(), String::GetExternalStringResource(), String::GetExternalStringResourceBase(), Object::GetIndexedPropertiesExternalArrayData(), Object::GetIndexedPropertiesPixelData(), CounterCollection::GetNextCounter(), CpuProfiler::GetProfile(), GraphWithImplicitRefs::GraphWithImplicitRefs(), HasWeakGlobalHandle(), Script::Id(), V8::IdleNotification(), Context::InContext(), ExecArgs::Init(), Isolate::Init(), JsHttpRequestProcessor::Initialize(), V8::Initialize(), Isolate::InitializeLoggingAndCounters(), CpuProfiler::INLINE(), V8::IsExecutionTerminating(), Locker::IsLocked(), HValueMap::Kill(), Isolate::LinkDeferredHandles(), Load(), Shell::Load(), Locker::Locker(), CounterMap::Lookup(), Builtins::Lookup(), HValueMap::Lookup(), Shell::LookupCounter(), V8::LowMemoryNotification(), main(), Shell::MakeDirectory(), Shell::MapCounters(), CounterMap::Iterator::More(), Script::New(), Function::NewInstance(), Shell::OnExit(), ScriptData::PreCompile(), ReadLineEditor::Prompt(), Read(), Shell::Read(), Utf8::ReadBlock(), Shell::ReadBuffer(), ReadFile(), Shell::ReadFile(), Shell::ReadFromStdin(), ReadLine(), Shell::RemoveDirectory(), SocketListenerThread::Run(), ThreadIdValidationThread::Run(), LoopingThread::Run(), Script::Run(), ShellThread::Run(), InitDefaultIsolateThread::Run(), RunMain(), Shell::RunMain(), RunShell(), v8::internal::RUNTIME_FUNCTION(), CounterMap::Set(), Shell::SetEnvironment(), v8::SetResourceConstraints(), Builtins::SetUp(), CodeGenerator::ShouldGenerateLog(), PreParserData::StackOverflow(), SourceGroup::StartExecuteInThread(), StartupDataDecompressor::StartupDataDecompressor(), Isolate::stats_table(), CpuProfiler::StopProfiling(), StoringErrorCallback(), Shell::System(), ApiTestFuzzer::TearDown(), Isolate::TearDown(), V8::TerminateExecution(), TEST(), TestParserSync(), THREADED_TEST(), Isolate::UnlinkDeferredHandles(), Unlocker::Unlocker(), RegisteredExtension::UnregisterAll(), Shell::UnsetEnvironment(), SourceGroup::WaitForThread(), String::WriteUtf8(), BinaryResource::~BinaryResource(), ExecArgs::~ExecArgs(), GraphWithImplicitRefs::~GraphWithImplicitRefs(), Isolate::~Isolate(), SourceGroup::~SourceGroup(), TestAsciiResource::~TestAsciiResource(), TestResource::~TestResource(), and ZombieProtector::~ZombieProtector().

Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with starts profiling automatically Used with prof

Definition at line 637 of file flag-definitions.h.

Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with starts profiling automatically true

Definition at line 135 of file flag-definitions.h.

activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen Z

Definition at line 185 of file flag-definitions.h.