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
Data Structures | Namespaces | Macros | Functions | Variables
flags.cc File Reference
#include <ctype.h>
#include <stdlib.h>
#include "v8.h"
#include "platform.h"
#include "smart-pointers.h"
#include "string-stream.h"
#include "flag-definitions.h"
Include dependency graph for flags.cc:

Go to the source code of this file.

Data Structures

struct  Flag
 

Namespaces

 v8
 
 v8::internal
 
 v8::internal::builtins
 

Macros

#define FLAG_MODE_DEFINE
 
#define FLAG_MODE_DEFINE_DEFAULTS
 
#define FLAG_MODE_META
 
#define FLAG_MODE_DEFINE_IMPLICATIONS
 

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
 
char NormalizeChar (char ch)
 

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
 
Flag flags []
 
const size_t num_flags = sizeof(flags) / sizeof(*flags)
 

Macro Definition Documentation

#define FLAG_MODE_DEFINE

Definition at line 42 of file flags.cc.

#define FLAG_MODE_DEFINE_DEFAULTS

Definition at line 46 of file flags.cc.

#define FLAG_MODE_DEFINE_IMPLICATIONS
#define FLAG_MODE_META