マクロ定義
#define	DEFINE_bool(nam, def, cmt) FLAG(BOOL, bool, nam, def, cmt)
#define	DEFINE_int(nam, def, cmt) FLAG(INT, int, nam, def, cmt)
#define	DEFINE_float(nam, def, cmt) FLAG(FLOAT, double, nam, def, cmt)
#define	DEFINE_string(nam, def, cmt) FLAG(STRING, const char*, nam, def, cmt)
#define	FLAG FLAG_FULL
#define	FLAG FLAG_READONLY
#define	FLAG FLAG_READONLY
#define	FLAG FLAG_READONLY
#define	FLAG_FULL(ftype, ctype, nam, def, cmt) ctype FLAG_##nam = def;
#define	FLAG_READONLY(ftype, ctype, nam, def, cmt)
#define	DEFINE_bool(nam, def, cmt) FLAG(BOOL, bool, nam, def, cmt)
#define	DEFINE_int(nam, def, cmt) FLAG(INT, int, nam, def, cmt)
#define	DEFINE_float(nam, def, cmt) FLAG(FLOAT, double, nam, def, cmt)
#define	DEFINE_string(nam, def, cmt) FLAG(STRING, const char*, nam, def, cmt)
#define	FLAG FLAG_FULL
#define	FLAG FLAG_READONLY
#define	FLAG FLAG_READONLY
#define	FLAG FLAG_READONLY
#define	FLAG_FULL(ftype, ctype, nam, def, cmt) static ctype const FLAGDEFAULT_##nam = def;
#define	FLAG_READONLY(ftype, ctype, nam, def, cmt)
#define	DEFINE_bool(nam, def, cmt) FLAG(BOOL, bool, nam, def, cmt)
#define	DEFINE_int(nam, def, cmt) FLAG(INT, int, nam, def, cmt)
#define	DEFINE_float(nam, def, cmt) FLAG(FLOAT, double, nam, def, cmt)
#define	DEFINE_string(nam, def, cmt) FLAG(STRING, const char*, nam, def, cmt)
#define	FLAG FLAG_FULL
#define	FLAG FLAG_READONLY
#define	FLAG FLAG_READONLY
#define	FLAG FLAG_READONLY
#define	DEFINE_bool(nam, def, cmt) FLAG(BOOL, bool, nam, def, cmt)
#define	DEFINE_int(nam, def, cmt) FLAG(INT, int, nam, def, cmt)
#define	DEFINE_float(nam, def, cmt) FLAG(FLOAT, double, nam, def, cmt)
#define	DEFINE_string(nam, def, cmt) FLAG(STRING, const char*, nam, def, cmt)
#define	FLAG FLAG_FULL
#define	FLAG FLAG_READONLY
#define	FLAG FLAG_READONLY
#define	FLAG FLAG_READONLY
#define	FLAG_FULL(ftype, ctype, nam, def, cmt) extern ctype FLAG_##nam;
#define	FLAG_READONLY(ftype, ctype, nam, def, cmt) static ctype const FLAG_##nam = def;
#define	DEFINE_bool(nam, def, cmt) FLAG(BOOL, bool, nam, def, cmt)
#define	DEFINE_int(nam, def, cmt) FLAG(INT, int, nam, def, cmt)
#define	DEFINE_float(nam, def, cmt) FLAG(FLOAT, double, nam, def, cmt)
#define	DEFINE_string(nam, def, cmt) FLAG(STRING, const char*, nam, def, cmt)
#define	FLAG FLAG_FULL
#define	FLAG FLAG_READONLY
#define	FLAG FLAG_READONLY
#define	FLAG FLAG_READONLY
関数
	DEFINE_bool (debug_code, false,"generate extra code (comments, assertions) for debugging") DEFINE_bool(emit_branch_hints
emit branch hints	DEFINE_bool (push_pop_elimination, true,"eliminate redundant push/pops in assembly code") DEFINE_bool(print_push_pop_elimination
emit branch hints print elimination of redundant push pops in assembly code	DEFINE_string (expose_natives_as, NULL,"expose natives in global object") DEFINE_string(expose_debug_as
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object	DEFINE_string (natives_file, NULL,"alternative natives file") DEFINE_bool(expose_gc
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension	DEFINE_bool (inline_new, true,"use fast inline allocation") DEFINE_bool(stack_trace_on_abort
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs	DEFINE_bool (trace, false,"trace function calls") DEFINE_bool(defer_negation
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation	DEFINE_bool (check_stack, true,"check stack for overflow, interrupt, breakpoint") DEFINE_bool(lazy
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation	DEFINE_bool (debug_info, true,"add debug information to compiled functions") DEFINE_bool(strict
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking	DEFINE_int (min_preparse_length, 1024,"Minimum length for automatic enable preparsing") DEFINE_bool(remote_debugging
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging	DEFINE_bool (trace_debug_json, false,"trace debugging JSON request/response") DEFINE_bool(call_regexp
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects	DEFINE_int (max_stack_trace_source_length, 300,"maximum length of function source code printed in a stack trace.") DEFINE_int(new_space_size
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size	of (each semispace in) the new generation") DEFINE_int(old_space_size
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation	DEFINE_bool (gc_global, false,"always perform global GCs") DEFINE_int(gc_interval
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations	DEFINE_bool (trace_gc, false,"print one trace line following each garbage collection") DEFINE_bool(collect_maps
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached	DEFINE_bool (use_ic, true,"use inline caching") DEFINE_bool(native_code_counters
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters	DEFINE_bool (always_compact, false,"Perform compaction on every full GC") DEFINE_bool(never_compact
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only	DEFINE_bool (cleanup_ics_at_gc, true,"Flush inline caches prior to mark compact collection.") DEFINE_bool(cleanup_caches_in_maps_at_gc
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle	DEFINE_bool (canonicalize_object_literal_maps, true,"Canonicalize maps for object literals.") DEFINE_bool(h
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message	DEFINE_bool (allow_natives_syntax, false,"allow natives syntax") DEFINE_bool(optimize_ast
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast	DEFINE_bool (trace_sim, false,"trace simulator execution") DEFINE_int(stop_sim_at
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions	DEFINE_bool (trace_exception, false,"print stack trace when throwing exceptions") DEFINE_bool(preallocate_message_memory
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces	DEFINE_bool (usage_computation, true,"compute variable usage counts") DEFINE_bool(preemption
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads	DEFINE_bool (testing_bool_flag, true,"testing_bool_flag") DEFINE_int(testing_int_flag
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag	DEFINE_float (testing_float_flag, 2.5,"float-flag") DEFINE_string(testing_string_flag
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag	DEFINE_int (testing_prng_seed, 42,"Seed used for threading test randomness") DEFINE_string(testing_serialization_file
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap	DEFINE_bool (dump_counters, false,"Dump counters on exit") DEFINE_bool(enable_slow_asserts
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute	DEFINE_bool (print_code_stubs, false,"print code stubs") DEFINE_bool(trace_codegen
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated	DEFINE_bool (print_builtin_code, false,"print generated code for builtins") DEFINE_bool(print_source
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code	DEFINE_bool (print_builtin_source, false,"pretty print source code for builtins") DEFINE_bool(print_ast
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST	DEFINE_bool (print_builtin_ast, false,"print source AST for builtins") DEFINE_bool(trace_calls
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls	DEFINE_bool (trace_builtin_calls, false,"trace builtins calls") DEFINE_string(stop_at
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls function name where to insert a breakpoint	DEFINE_bool (print_builtin_scopes, false,"print scopes for builtins") DEFINE_bool(print_scopes
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls function name where to insert a breakpoint print scopes	DEFINE_bool (trace_contexts, false,"trace contexts operations") DEFINE_bool(gc_greedy
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls 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
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls 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_heap
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC verify heap pointers before and after GC	DEFINE_bool (print_handles, false,"report handles after GC") DEFINE_bool(print_global_handles
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC verify heap pointers before and after GC report global handles after GC	DEFINE_bool (print_rset, false,"print remembered sets before GC") DEFINE_bool(trace_ic
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC verify heap pointers before and after GC report global handles after GC trace cache state transitions	DEFINE_bool (trace_normalization, false,"prints when objects are turned into dictionaries.") DEFINE_bool(trace_lazy
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC verify heap pointers before and after GC report global handles after GC trace cache state transitions trace lazy compilation	DEFINE_bool (debug_serialization, false,"write debug information into the snapshot.") DEFINE_bool(collect_heap_spill_statistics
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC verify heap pointers before and after GC report global handles after GC trace cache state transitions trace lazy compilation report heap spill statistics along with	heap_stats (requires heap_stats)") DEFINE_bool(log
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC verify heap pointers before and after GC report global handles after GC trace cache state transitions trace lazy compilation report heap spill statistics along with Minimal	logging (no API, code, GC, suspect, or handles samples).") DEFINE_bool(log_all
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC verify heap pointers before and after GC report global handles after GC trace cache state transitions trace lazy compilation report heap spill statistics along with Minimal Log all events to the log file	DEFINE_bool (log_api, false,"Log API events to the log file.") DEFINE_bool(log_code
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC verify heap pointers before and after GC report global handles after GC trace cache state transitions trace lazy compilation report heap spill statistics along with Minimal Log all events to the log file Log code events to the log file without profiling	DEFINE_bool (log_gc, false,"Log heap samples on garbage collection for the hp2ps tool.") DEFINE_bool(log_handles
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC verify heap pointers before and after GC report global handles after GC trace cache state transitions trace lazy compilation report heap spill statistics along with Minimal Log all events to the log file Log code events to the log file without profiling Log global handle events	DEFINE_bool (log_state_changes, false,"Log state changes.") DEFINE_bool(log_suspect
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC verify heap pointers before and after GC report global handles after GC trace cache state transitions trace lazy compilation report heap spill statistics along with Minimal Log all events to the log file Log code events to the log file without profiling Log global handle events Log suspect operations	DEFINE_bool (prof, false,"Log statistical profiling information (implies --log-code).") DEFINE_bool(log_regexp
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC verify heap pointers before and after GC report global handles after GC trace cache state transitions trace lazy compilation report heap spill statistics along with Minimal Log all events to the log file Log code events to the log file without profiling Log global handle events Log suspect operations Log regular expression execution	DEFINE_bool (sliding_state_window, false,"Update sliding state window counters.") DEFINE_string(logfile
変数
	false
emit branch hints print elimination of redundant push pops in assembly code	NULL
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension	true
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag	Hello
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag	world
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp	serdes
emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC verify heap pointers before and after GC report global handles after GC trace cache state transitions trace lazy compilation report heap spill statistics along with Minimal Log all events to the log file Log code events to the log file without profiling Log global handle events Log suspect operations Log regular expression execution v8	log

マクロ定義

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

flags.h の 73 行で定義されています。

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

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

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

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

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

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

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

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

flags.h の 75 行で定義されています。

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

#define DEFINE_int	(	nam,
		def,
		cmt
	)		FLAG(INT, int, nam, def, cmt)

flags.h の 74 行で定義されています。

#define DEFINE_int	(	nam,
		def,
		cmt
	)		FLAG(INT, int, nam, def, cmt)

#define DEFINE_int	(	nam,
		def,
		cmt
	)		FLAG(INT, int, nam, def, cmt)

#define DEFINE_int	(	nam,
		def,
		cmt
	)		FLAG(INT, int, nam, def, cmt)

#define DEFINE_int	(	nam,
		def,
		cmt
	)		FLAG(INT, int, nam, def, cmt)

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

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

flags.h の 76 行で定義されています。

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

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

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

#define FLAG FLAG_READONLY

#define FLAG FLAG_FULL

#define FLAG FLAG_READONLY

flags.h の 309 行で定義されています。

#define FLAG FLAG_READONLY

#define FLAG FLAG_FULL

#define FLAG FLAG_READONLY

#define FLAG FLAG_FULL

#define FLAG FLAG_READONLY

flags.h の 309 行で定義されています。

#define FLAG FLAG_FULL

flags.h の 309 行で定義されています。

#define FLAG FLAG_READONLY

#define FLAG FLAG_FULL

#define FLAG FLAG_READONLY

flags.h の 309 行で定義されています。

#define FLAG_FULL	(	ftype,
		ctype,
		nam,
		def,
		cmt
	)		extern ctype FLAG_##nam;

#define FLAG_FULL	(	ftype,
		ctype,
		nam,
		def,
		cmt
	)		static ctype const FLAGDEFAULT_##nam = def;

#define FLAG_FULL	(	ftype,
		ctype,
		nam,
		def,
		cmt
	)		ctype FLAG_##nam = def;

#define FLAG_READONLY	(	ftype,
		ctype,
		nam,
		def,
		cmt
	)

#define FLAG_READONLY	(	ftype,
		ctype,
		nam,
		def,
		cmt
	)		static ctype const FLAG_##nam = def;

#define FLAG_READONLY	(	ftype,
		ctype,
		nam,
		def,
		cmt
	)

関数

DEFINE_bool	(	debug_code	,
		false	,
		"generate extra code (comments, assertions) for debugging"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC verify heap pointers before and after GC report global handles after GC trace cache state transitions trace lazy compilation report heap spill statistics along with Minimal Log all events to the log file Log code events to the log file without profiling Log global handle events Log suspect operations Log regular expression execution DEFINE_bool	(	sliding_state_window	,
		false	,
		"Update sliding state window counters."
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC verify heap pointers before and after GC report global handles after GC trace cache state transitions trace lazy compilation report heap spill statistics along with Minimal Log all events to the log file Log code events to the log file without profiling Log global handle events Log suspect operations DEFINE_bool	(	prof	,
		false	,
		"Log statistical profiling information (implies --log-code)."
	)

emit branch hints DEFINE_bool	(	push_pop_elimination	,
		true	,
		"eliminate redundant push/pops in assembly code"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC verify heap pointers before and after GC report global handles after GC trace cache state transitions trace lazy compilation report heap spill statistics along with Minimal Log all events to the log file Log code events to the log file without profiling DEFINE_bool	(	log_gc	,
		false	,
		"Log heap samples on garbage collection for the hp2ps tool."
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC verify heap pointers before and after GC report global handles after GC trace cache state transitions trace lazy compilation report heap spill statistics along with Minimal Log all events to the log file DEFINE_bool	(	log_api	,
		false	,
		"Log API events to the log file."
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation DEFINE_bool	(	debug_info	,
		true	,
		"add debug information to compiled functions"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters DEFINE_bool	(	always_compact	,
		false	,
		"Perform compaction on every full GC"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC verify heap pointers before and after GC report global handles after GC trace cache state transitions trace lazy compilation DEFINE_bool	(	debug_serialization	,
		false	,
		"write debug information into the snapshot."
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC verify heap pointers before and after GC report global handles after GC trace cache state transitions DEFINE_bool	(	trace_normalization	,
		false	,
		"prints when objects are turned into dictionaries."
	)			`[inline]`

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC verify heap pointers before and after GC report global handles after GC DEFINE_bool	(	print_rset	,
		false	,
		"print remembered sets before GC"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls function name where to insert a breakpoint DEFINE_bool	(	print_builtin_scopes	,
		false	,
		"print scopes for builtins"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls function name where to insert a breakpoint print scopes DEFINE_bool	(	trace_contexts	,
		false	,
		"trace contexts operations"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only DEFINE_bool	(	cleanup_ics_at_gc	,
		true	,
		"Flush inline caches prior to mark compact collection."
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls 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"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls 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"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls DEFINE_bool	(	trace_builtin_calls	,
		false	,
		"trace builtins calls"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST DEFINE_bool	(	print_builtin_ast	,
		false	,
		"print source AST for builtins"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code DEFINE_bool	(	print_builtin_source	,
		false	,
		"pretty print source code for builtins"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated DEFINE_bool	(	print_builtin_code	,
		false	,
		"print generated code for builtins"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute DEFINE_bool	(	print_code_stubs	,
		false	,
		"print code stubs"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle DEFINE_bool	(	canonicalize_object_literal_maps	,
		true	,
		"Canonicalize maps for object literals."
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC verify heap pointers before and after GC DEFINE_bool	(	print_handles	,
		false	,
		"report handles after GC"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message DEFINE_bool	(	allow_natives_syntax	,
		false	,
		"allow natives syntax"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads DEFINE_bool	(	testing_bool_flag	,
		true	,
		"testing_bool_flag"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC verify heap pointers before and after GC report global handles after GC trace cache state transitions trace lazy compilation report heap spill statistics along with Minimal Log all events to the log file Log code events to the log file without profiling Log global handle events DEFINE_bool	(	log_state_changes	,
		false	,
		"Log state changes."
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions DEFINE_bool	(	trace_exception	,
		false	,
		"print stack trace when throwing exceptions"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension DEFINE_bool	(	inline_new	,
		true	,
		"use fast inline allocation"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging DEFINE_bool	(	trace_debug_json	,
		false	,
		"trace debugging JSON request/response"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast DEFINE_bool	(	trace_sim	,
		false	,
		"trace simulator execution"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces DEFINE_bool	(	usage_computation	,
		true	,
		"compute variable usage counts"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs DEFINE_bool	(	trace	,
		false	,
		"trace function calls"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached DEFINE_bool	(	use_ic	,
		true	,
		"use inline caching"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations DEFINE_bool	(	trace_gc	,
		false	,
		"print one trace line following each garbage collection"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation DEFINE_bool	(	gc_global	,
		false	,
		"always perform global GCs"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap DEFINE_bool	(	dump_counters	,
		false	,
		"Dump counters on exit"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation DEFINE_bool	(	check_stack	,
		true	,
		"check stack for	overflow,
		interrupt	,
		breakpoint"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag DEFINE_float	(	testing_float_flag	,
		2.	5,
		"float-flag"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking DEFINE_int	(	min_preparse_length	,
		1024	,
		"Minimum length for automatic enable preparsing"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag DEFINE_int	(	testing_prng_seed	,
		42	,
		"Seed used for threading test randomness"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects DEFINE_int	(	max_stack_trace_source_length	,
		300	,
		"maximum length of function source code printed in a stack trace."
	)

emit branch hints print elimination of redundant push pops in assembly code DEFINE_string	(	expose_natives_as	,
		NULL	,
		"expose natives in global object"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object DEFINE_string	(	natives_file	,
		NULL	,
		"alternative natives file"
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC verify heap pointers before and after GC report global handles after GC trace cache state transitions trace lazy compilation report heap spill statistics along with heap_stats ( requires heap_stats )

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC verify heap pointers before and after GC report global handles after GC trace cache state transitions trace lazy compilation report heap spill statistics along with Minimal logging	(	no	API,
		code	,
		GC	,
		suspect	,
		or handles	samples
	)

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size of ( each semispace in ) [new]

変数

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC verify heap pointers before and after GC report global handles after GC trace cache state transitions trace lazy compilation report heap spill statistics along with Minimal Log all events to the log file Log code events to the log file without profiling Log global handle events Log suspect operations false

flag-definitions.h の 85 行で定義されています。

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag Hello

flag-definitions.h の 189 行で定義されています。

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp file in which to serialize heap enable asserts that are slow to execute print name of functions for which code is generated pretty print source code print source AST trace calls function name where to insert a breakpoint print scopes perform GC prior to some allocations report heap statistics before and after GC verify heap pointers before and after GC report global handles after GC trace cache state transitions trace lazy compilation report heap spill statistics along with Minimal Log all events to the log file Log code events to the log file without profiling Log global handle events Log suspect operations Log regular expression execution v8 log

flag-definitions.h の 299 行で定義されています。

emit branch hints print elimination of redundant push pops in assembly code NULL

flag-definitions.h の 93 行で定義されています。

参照元 v8::FunctionTemplate::AddInstancePropertyAccessor(), v8::String::AsciiValue::AsciiValue(), v8::Function::Call(), CheckNonEqualsHelper(), v8::Script::Compile(), compileBranch(), v8::ReadLineEditor::CompletionGenerator(), counter_callback(), v8::HandleScope::CreateHandle(), assembler::arm::Simulator::current(), disasm::DisassemblerIA32::D1D3C1Instruction(), disasm::F0Mnem(), disasm::DisassemblerIA32::F7Instruction(), v8::internal::FindFlag(), disasm::DisassemblerIA32::FPUInstruction(), v8::LineEditor::Get(), v8::GetFatalErrorHandler(), CounterCollection::GetNextCounter(), v8::V8::GlobalizeReference(), v8::Context::InContext(), v8::HandleScope::Data::Initialize(), v8::Shell::Initialize(), v8::V8::Initialize(), disasm::DisassemblerIA32::InstructionDecode(), jsRegExpCompile(), disasm::DisassemblerIA32::JumpConditional(), disasm::DisassemblerIA32::JumpConditionalShort(), match(), v8::Function::NewInstance(), v8::ScriptData::PreCompile(), unibrow::Utf8::ReadBlock(), v8::Shell::ReadFile(), v8::internal::ReadSentinel(), v8::Script::Run(), v8::internal::SplitArgument(), v8::String::Utf8Value::Utf8Value(), v8::String::Value::Value(), WriteInternalSnapshotToFile(), v8::internal::WriteSentinel(), と v8::HandleScope::ZapRange().

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag string flag tmp serdes

flag-definitions.h の 195 行で定義されています。

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after< n > allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message true

flag-definitions.h の 101 行で定義されています。

emit branch hints print elimination of redundant push pops in assembly code expose debug in global object expose gc extension print a stack trace if an assertion failure occurs defer negation operation use lazy compilation strict error checking enable remote debugging allow calls to RegExp objects size size of the old generation garbage collect after<n> allocations garbage collect maps from which no objects can be reached generate extra code for manipulating stats counters Never perform compaction on full GC testing only Flush code caches in maps during mark compact cycle print this message optimize the ast Simulator stop after x number of instructions preallocate some memory to build stack traces activate a timer that switches between V8 threads testing_int_flag world

flag-definitions.h の 189 行で定義されています。

src/flag-definitions.h

マクロ定義

関数

変数

マクロ定義

関数

変数