#include "checks.h"#include "flag-definitions.h"ネームスペース | |
| namespace | v8 |
| namespace | v8::internal |
マクロ定義 | |
| #define | FLAG_MODE_DECLARE |
関数 | |
| v8::internal::DEFINE_bool (debug_code, false,"generate extra code (comments, assertions) for debugging") DEFINE_bool(emit_branch_hints | |
| emit branch hints | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::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 | v8::internal::DEFINE_bool (sliding_state_window, false,"Update sliding state window counters.") DEFINE_string(logfile |
| v8::internal::DEFINE_bool (print_code, false,"print generated code") DEFINE_bool(debug_code | |
1.7.1