39 #if defined(FLAG_MODE_DECLARE)
40 #define FLAG_FULL(ftype, ctype, nam, def, cmt) \
41 extern ctype FLAG_##nam;
42 #define FLAG_READONLY(ftype, ctype, nam, def, cmt) \
43 static ctype const FLAG_##nam = def;
44 #define DEFINE_implication(whenflag, thenflag)
48 #elif defined(FLAG_MODE_DEFINE)
49 #define FLAG_FULL(ftype, ctype, nam, def, cmt) \
50 ctype FLAG_##nam = def;
51 #define FLAG_READONLY(ftype, ctype, nam, def, cmt)
52 #define DEFINE_implication(whenflag, thenflag)
57 #elif defined(FLAG_MODE_DEFINE_DEFAULTS)
58 #define FLAG_FULL(ftype, ctype, nam, def, cmt) \
59 static ctype const FLAGDEFAULT_##nam = def;
60 #define FLAG_READONLY(ftype, ctype, nam, def, cmt)
61 #define DEFINE_implication(whenflag, thenflag)
65 #elif defined(FLAG_MODE_META)
66 #define FLAG_FULL(ftype, ctype, nam, def, cmt) \
67 { Flag::TYPE_##ftype, #nam, &FLAG_##nam, &FLAGDEFAULT_##nam, cmt, false },
68 #define FLAG_READONLY(ftype, ctype, nam, def, cmt)
69 #define DEFINE_implication(whenflag, thenflag)
72 #elif defined(FLAG_MODE_DEFINE_IMPLICATIONS)
73 #define FLAG_FULL(ftype, ctype, nam, def, cmt)
74 #define FLAG_READONLY(ftype, ctype, nam, def, cmt)
75 #define DEFINE_implication(whenflag, thenflag) \
76 if (FLAG_##whenflag) FLAG_##thenflag = true;
79 #error No mode supplied when including flags.defs
82 #ifdef FLAG_MODE_DECLARE
84 #define JSARGUMENTS_INIT {{}}
87 inline int argc()
const {
88 return static_cast<int>(storage_[0]);
90 inline const char** argv()
const {
91 return reinterpret_cast<const char**
>(storage_[1]);
93 inline const char*& operator[] (
int idx)
const {
96 inline JSArguments& operator=(JSArguments args) {
97 set_argc(args.argc());
98 set_argv(args.argv());
101 static JSArguments Create(
int argc,
const char** argv) {
108 void set_argc(
int argc) {
111 void set_argv(
const char** argv) {
112 storage_[1] =
reinterpret_cast<AtomicWord>(argv);
122 #define DEFINE_bool(nam, def, cmt) FLAG(BOOL, bool, nam, def, cmt)
123 #define DEFINE_int(nam, def, cmt) FLAG(INT, int, nam, def, cmt)
124 #define DEFINE_float(nam, def, cmt) FLAG(FLOAT, double, nam, def, cmt)
125 #define DEFINE_string(nam, def, cmt) FLAG(STRING, const char*, nam, def, cmt)
126 #define DEFINE_args(nam, def, cmt) FLAG(ARGS, JSArguments, nam, def, cmt)
131 #define FLAG FLAG_FULL
134 DEFINE_bool(use_strict,
false,
"enforce strict mode")
136 "activate correct semantics for inheriting readonliness")
138 "activate new semantics for global var declarations")
141 DEFINE_bool(harmony_scoping, false, "enable harmony block scoping")
143 "enable harmony
modules (implies block scoping)")
144 DEFINE_bool(harmony_proxies, false, "enable harmony proxies")
146 "enable harmony collections (sets, maps, and weak maps)")
155 DEFINE_bool(packed_arrays, true, "optimizes arrays that have no holes")
156 DEFINE_bool(smi_only_arrays, true, "tracks arrays with only smi values")
159 "Optimize
object size, Array shift, DOM strings and
string +")
162 DEFINE_bool(unbox_double_arrays, true, "automatically unbox arrays
of doubles")
163 DEFINE_bool(string_slices, true, "use
string slices")
168 DEFINE_bool(use_range, true, "use hydrogen range analysis")
169 DEFINE_bool(eliminate_dead_phis, true, "eliminate dead phis")
170 DEFINE_bool(use_gvn, true, "use hydrogen global value numbering")
171 DEFINE_bool(use_canonicalizing, true, "use hydrogen instruction canonicalizing")
172 DEFINE_bool(use_inlining, true, "use function inlining")
174 "maximum source size in bytes considered for a single inlining")
176 "maximum number
of AST nodes considered for a single inlining")
178 "maximum cumulative number
of AST nodes considered for inlining")
179 DEFINE_bool(loop_invariant_code_motion, true, "loop invariant
code motion")
180 DEFINE_bool(collect_megamorphic_maps_from_stub_cache,
182 "crankshaft harvests type feedback from stub cache")
183 DEFINE_bool(hydrogen_stats, false, "print statistics for hydrogen")
184 DEFINE_bool(trace_hydrogen, false, "trace generated hydrogen to file")
186 DEFINE_bool(trace_inlining, false, "trace inlining decisions")
187 DEFINE_bool(trace_alloc, false, "trace register allocator")
188 DEFINE_bool(trace_all_uses, false, "trace all use positions")
189 DEFINE_bool(trace_range, false, "trace range analysis")
190 DEFINE_bool(trace_gvn, false, "trace global value numbering")
191 DEFINE_bool(trace_representation, false, "trace representation types")
192 DEFINE_bool(stress_pointer_maps, false, "pointer map for every instruction")
193 DEFINE_bool(stress_environments, false, "environment for every instruction")
196 "deoptimize every n times a deopt point is passed")
197 DEFINE_bool(trap_on_deopt, false, "put a break point before deoptimizing")
198 DEFINE_bool(deoptimize_uncommon_cases, true, "deoptimize uncommon cases")
199 DEFINE_bool(polymorphic_inlining, true, "polymorphic inlining")
200 DEFINE_bool(use_osr, true, "use on-stack replacement")
202 "perform array bounds checks elimination")
204 "perform array index dehoisting")
206 DEFINE_bool(trace_dead_code_elimination, false, "trace dead
code elimination")
208 DEFINE_bool(trace_osr, false, "trace on-stack replacement")
210 DEFINE_bool(optimize_closures, true, "optimize closures")
212 "when picking a function to optimize, watch for shared function "
213 "info, not JSFunction itself")
215 "cache optimized
code for closures")
216 DEFINE_bool(inline_construct, true, "inline constructor calls")
217 DEFINE_bool(inline_arguments, true, "inline functions with arguments
object")
218 DEFINE_bool(inline_accessors, true, "inline JavaScript accessors")
219 DEFINE_int(loop_weight, 1, "loop weight for representation inference")
222 "optimize functions containing for-in loops")
224 "allow uint32 values on optimize frames if they are used only in"
228 "optimizing hot functions asynchronously on a separate thread")
229 DEFINE_bool(trace_parallel_recompilation, false, "track parallel recompilation")
230 DEFINE_int(parallel_recompilation_queue_length, 2,
231 "the length
of the parallel compilation queue")
234 DEFINE_bool(experimental_profiler, true, "enable all profiler experiments")
235 DEFINE_bool(watch_ic_patching, false, "profiler considers IC stability")
236 DEFINE_int(frame_count, 1, "number
of stack frames inspected by the profiler")
238 "primitive functions trigger their own optimization")
240 "call recompile stub directly when self-optimizing")
241 DEFINE_bool(retry_self_opt, false, "re-try self-optimization if it failed")
243 "trigger profiler ticks based on counting instead
of timing")
245 "insert an interrupt
check at function exit")
247 "weight back edges by jump distance for interrupt triggering")
250 "execution budget before interrupt is triggered")
252 "percentage
of ICs that must have type info to allow optimization")
253 DEFINE_int(self_opt_count, 130, "call count before self-optimization")
263 DEFINE_bool(trace_opt_verbose, false, "extra verbose compilation tracing")
292 "enable loading 32-bit constant by means
of movw/movt "
293 "instruction
pairs (ARM only)")
295 "enable unaligned accesses for
ARMv7 (ARM only)")
301 DEFINE_string(expose_debug_as, NULL, "expose debug in global
object")
302 DEFINE_bool(expose_gc, false, "expose gc extension")
304 "expose externalize
string extension")
305 DEFINE_int(stack_trace_limit, 10, "number
of stack frames to capture")
307 "show built-in functions in stack traces")
308 DEFINE_bool(disable_native_files, false, "disable builtin natives files")
311 DEFINE_bool(inline_new, true, "use fast inline allocation")
315 "print a stack trace if an assertion failure occurs")
321 "use
random jit cookie to mask large constants")
325 DEFINE_bool(trace_opt, false, "trace lazy optimization")
326 DEFINE_bool(trace_opt_stats, false, "trace lazy optimization statistics")
327 DEFINE_bool(opt, true, "use adaptive optimizations")
330 DEFINE_bool(trace_deopt, false, "trace deoptimization")
334 "minimum length for automatic enable preparsing")
336 "try to use the dedicated run-once backend for all
code")
338 "maximum number
of optimization attempts before giving up.")
341 DEFINE_bool(compilation_cache, true, "enable compilation cache")
343 DEFINE_bool(cache_prototype_transitions, true, "cache prototype transitions")
346 DEFINE_bool(trace_debug_json, false, "trace debugging JSON request/response")
348 "automatically set the debug break
flag when debugger commands are "
350 DEFINE_bool(enable_liveedit, true, "enable liveedit experimental feature")
357 "default size
of stack region v8 is allowed to use (in kBytes)")
360 DEFINE_int(max_stack_trace_source_length, 300,
361 "maximum length
of function source
code printed in a stack trace.")
372 DEFINE_int(gc_interval, -1, "garbage collect after <n> allocations")
374 "print one trace line following each garbage collection")
376 "print one detailed trace line in name=value format "
377 "after each garbage collection")
379 "do not print trace line after scavenger collection")
381 "print cumulative GC statistics in name=value format on exit")
383 "print more details following each garbage collection")
385 "report fragmentation for old pointer and data pages")
387 "print amount
of external allocated
memory after each time "
390 "garbage collect maps from which no objects can be reached")
392 "flush
code that we expect not to use again before full gc")
393 DEFINE_bool(incremental_marking, true, "use incremental marking")
394 DEFINE_bool(incremental_marking_steps, true, "do incremental marking steps")
396 "trace progress
of the incremental marking")
398 "track
object counts and
memory usage")
400 DEFINE_bool(verify_heap,
false,
"verify heap pointers before and after GC")
405 "Use idle notification to reduce memory footprint.")
409 #ifdef LIVE_OBJECT_LIST
412 DEFINE_bool(verify_lol, false, "perform debugging verification for lol")
417 "generate extra code for manipulating stats counters")
420 DEFINE_bool(always_compact, false, "Perform compaction on every full GC")
422 "Use lazy sweeping for old pointer and data spaces")
424 "Never perform compaction on full GC - testing only")
426 "Compact
code space on full non-incremental collections")
428 "Compact
code space on full incremental collections")
430 "
Flush inline caches prior to mark compact collection and "
431 "flush
code caches in maps during mark compact cycle.")
434 "(0, the default, means to use system
random).")
437 DEFINE_bool(use_verbose_printer, true, "allows verbose printing")
440 DEFINE_bool(allow_natives_syntax, false, "allow natives syntax")
441 DEFINE_bool(trace_parse, false, "trace parsing and preparsing")
446 "Check icache flushes in ARM and MIPS
simulator")
449 "Stack alingment in bytes in
simulator (4 or 8, 8 is default)")
453 "print stack trace when throwing exceptions")
455 "preallocate some
memory to build stack traces.")
458 "randomize hashes to avoid predictable hash
collisions "
459 "(with snapshots this option cannot override the baked-in
seed)")
463 "(with snapshots this option cannot override the baked-in
seed)")
467 "activate a 100ms timer that switches between V8 threads")
473 DEFINE_bool(testing_bool_flag, true, "testing_bool_flag")
474 DEFINE_int(testing_int_flag, 13, "testing_int_flag")
477 DEFINE_int(testing_prng_seed, 42, "Seed used for threading test randomness")
479 DEFINE_string(testing_serialization_file,
"C:\\Windows\\Temp\\serdes",
480 "file in which to testing_serialize heap")
483 "file in which to serialize heap")
487 DEFINE_string(extra_code, NULL,
"A filename with extra code to be included in"
488 " the snapshot (mksnapshot only)")
495 DEFINE_bool(dump_counters, false, "Dump counters on exit")
497 #ifdef ENABLE_DEBUGGER_SUPPORT
498 DEFINE_bool(debugger,
false,
"Enable JavaScript debugger")
499 DEFINE_bool(remote_debugger, false, "Connect JavaScript debugger to the "
500 "debugger agent in another process")
501 DEFINE_bool(debugger_agent, false, "Enable debugger agent")
502 DEFINE_int(debugger_port, 5858, "Port to use for remote debugging")
503 #endif // ENABLE_DEBUGGER_SUPPORT
507 "Pass all remaining arguments to the script. Alias for \"--\".")
510 DEFINE_bool(debug_compile_events,
false,
"Enable debugger compile events")
512 "Enable debugger script collected events")
514 DEFINE_bool(debug_compile_events,
true,
"Enable debugger compile events")
516 "Enable debugger script collected events")
524 DEFINE_bool(gdbjit,
false,
"enable GDBJIT interface (disables compacting GC)")
526 DEFINE_bool(gdbjit_dump, false, "dump elf objects with debug info to disk")
528 "dump only objects containing this substring")
532 "force overflows
of marking deque by reducing it's size "
536 "stress the GC compactor to flush out
bugs (implies "
537 "--force_marking_deque_overflows)")
544 #define FLAG FLAG_FULL
546 #define FLAG FLAG_READONLY
551 "enable asserts that are slow to execute")
555 "print name
of functions for which
code is generated")
558 "pretty print source
code for builtins")
560 DEFINE_bool(print_builtin_ast, false, "print source AST for builtins")
561 DEFINE_string(stop_at, "", "function name where to insert a breakpoint")
564 DEFINE_bool(print_builtin_scopes, false, "print scopes for builtins")
568 DEFINE_bool(trace_contexts, false, "trace contexts operations")
571 DEFINE_bool(gc_greedy, false, "perform GC prior to some allocations")
572 DEFINE_bool(gc_verbose, false, "print stuff during garbage collection")
573 DEFINE_bool(heap_stats, false, "report heap statistics before and after GC")
575 DEFINE_bool(verify_native_context_separation, false,
576 "verify that
code holds on to at most one native context after GC")
577 DEFINE_bool(print_handles, false, "report handles after GC")
578 DEFINE_bool(print_global_handles, false, "report global handles after GC")
581 DEFINE_bool(trace_ic, false, "trace inline cache state transitions")
584 DEFINE_bool(print_interfaces, false, "print interfaces")
586 DEFINE_int(print_interface_depth, 5, "depth for printing interfaces")
591 "prints when objects are turned into dictionaries.")
594 DEFINE_bool(trace_lazy, false, "trace lazy compilation")
598 "report heap spill statistics along with heap_stats "
599 "(requires heap_stats)")
601 DEFINE_bool(trace_isolates, false, "trace isolate state changes")
604 DEFINE_bool(log_state_changes, false, "Log state changes.")
609 "enable possessive quantifier syntax for testing")
610 DEFINE_bool(trace_regexp_bytecodes, false, "trace regexp bytecode execution")
613 "trace regexp macro assembler calls.")
619 #define FLAG FLAG_FULL
623 "Minimal logging (no API, code, GC, suspect, or handles samples).")
624 DEFINE_bool(log_all, false, "Log all events to the log file.")
625 DEFINE_bool(log_runtime, false, "Activate runtime system %Log call.")
626 DEFINE_bool(log_api, false, "Log API events to the log file.")
628 "Log
code events to the log file without profiling.")
630 "Log heap samples on garbage collection for the hp2ps tool.")
631 DEFINE_bool(log_handles, false, "Log global handle events.")
633 "log positions
of (de)serialized objects in the
snapshot.")
634 DEFINE_bool(log_suspect, false, "Log suspect operations.")
636 "Log statistical profiling information (implies --log-
code).")
638 "Used with --prof, starts profiling automatically")
640 "Used with --prof, only does sampling and logging"
641 " when profiler is active (implies --noprof_auto).")
643 "Used with --prof, turns on browser-compatible mode for profiling.")
644 DEFINE_bool(log_regexp, false, "Log regular expression execution.")
646 "Update sliding state window counters.")
648 DEFINE_bool(ll_prof, false, "Enable low-level linux profiler.")
650 "Specify the name
of the file for fake gc mmap used in ll_prof")
656 #ifdef ENABLE_DISASSEMBLER
657 #define FLAG FLAG_FULL
659 #define FLAG FLAG_READONLY
663 DEFINE_bool(trace_elements_transitions,
false,
"trace elements transitions")
669 "test secondary stub cache by disabling the primary one")
673 "test primary stub cache by disabling the secondary one")
679 "printing optimized
code based on it")
680 DEFINE_bool(print_code_verbose, false, "print more information for
code")
681 DEFINE_bool(print_builtin_code, false, "print generated
code for builtins")
683 #ifdef ENABLE_DISASSEMBLER
684 DEFINE_bool(print_all_code,
false,
"enable all flags related to printing code")
705 #undef DEFINE_implication
707 #undef FLAG_MODE_DECLARE
708 #undef FLAG_MODE_DEFINE
709 #undef FLAG_MODE_DEFINE_DEFAULTS
710 #undef FLAG_MODE_META
711 #undef FLAG_MODE_DEFINE_IMPLICATIONS
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize 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 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 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
v8::Handle< v8::Value > Print(const v8::Arguments &args)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize 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
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony modules(implies block scoping)") DEFINE_bool(harmony_proxies
#define DEFINE_float(nam, def, cmt)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize 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 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 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 pairs(ARM only)") DEFINE_bool(enable_unaligned_accesses
#define DEFINE_int(nam, def, cmt)
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 trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize 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
#define DEFINE_args(nam, def, cmt)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize 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 Z
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
void generate(MacroAssembler *masm, i::Vector< const char > string)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize 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 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
#define DEFINE_string(nam, def, cmt)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize 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
#define DEFINE_bool(nam, def, cmt)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize 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 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 harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize 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
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
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize 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
void check(i::Vector< const char > string)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize 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
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
kPropertyAccessorsOffset kNamedPropertyHandlerOffset kInstanceTemplateOffset kAccessCheckInfoOffset kEvalFrominstructionsOffsetOffset kInstanceClassNameOffset flag