v8  3.14.5(node0.10.28)
V8 is Google's open source JavaScript engine
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
flag-definitions.h
Go to the documentation of this file.
1 // Copyright 2012 the V8 project authors. All rights reserved.
2 // Redistribution and use in source and binary forms, with or without
3 // modification, are permitted provided that the following conditions are
4 // met:
5 //
6 // * Redistributions of source code must retain the above copyright
7 // notice, this list of conditions and the following disclaimer.
8 // * Redistributions in binary form must reproduce the above
9 // copyright notice, this list of conditions and the following
10 // disclaimer in the documentation and/or other materials provided
11 // with the distribution.
12 // * Neither the name of Google Inc. nor the names of its
13 // contributors may be used to endorse or promote products derived
14 // from this software without specific prior written permission.
15 //
16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 
28 // This file defines all of the flags. It is separated into different section,
29 // for Debug, Release, Logging and Profiling, etc. To add a new flag, find the
30 // correct section, and use one of the DEFINE_ macros, without a trailing ';'.
31 //
32 // This include does not have a guard, because it is a template-style include,
33 // which can be included multiple times in different modes. It expects to have
34 // a mode defined before it's included. The modes are FLAG_MODE_... below:
35 
36 // We want to declare the names of the variables for the header file. Normally
37 // this will just be an extern declaration, but for a readonly flag we let the
38 // compiler make better optimizations by giving it the value.
39 #if defined(FLAG_MODE_DECLARE)
40 #define FLAG_FULL(ftype, ctype, nam, def, cmt) \
41  extern ctype FLAG_##nam;
42 #define FLAG_READONLY(ftype, ctype, nam, def, cmt) \
43  static ctype const FLAG_##nam = def;
44 #define DEFINE_implication(whenflag, thenflag)
45 
46 // We want to supply the actual storage and value for the flag variable in the
47 // .cc file. We only do this for writable flags.
48 #elif defined(FLAG_MODE_DEFINE)
49 #define FLAG_FULL(ftype, ctype, nam, def, cmt) \
50  ctype FLAG_##nam = def;
51 #define FLAG_READONLY(ftype, ctype, nam, def, cmt)
52 #define DEFINE_implication(whenflag, thenflag)
53 
54 // We need to define all of our default values so that the Flag structure can
55 // access them by pointer. These are just used internally inside of one .cc,
56 // for MODE_META, so there is no impact on the flags interface.
57 #elif defined(FLAG_MODE_DEFINE_DEFAULTS)
58 #define FLAG_FULL(ftype, ctype, nam, def, cmt) \
59  static ctype const FLAGDEFAULT_##nam = def;
60 #define FLAG_READONLY(ftype, ctype, nam, def, cmt)
61 #define DEFINE_implication(whenflag, thenflag)
62 
63 // We want to write entries into our meta data table, for internal parsing and
64 // printing / etc in the flag parser code. We only do this for writable flags.
65 #elif defined(FLAG_MODE_META)
66 #define FLAG_FULL(ftype, ctype, nam, def, cmt) \
67  { Flag::TYPE_##ftype, #nam, &FLAG_##nam, &FLAGDEFAULT_##nam, cmt, false },
68 #define FLAG_READONLY(ftype, ctype, nam, def, cmt)
69 #define DEFINE_implication(whenflag, thenflag)
70 
71 // We produce the code to set flags when it is implied by another flag.
72 #elif defined(FLAG_MODE_DEFINE_IMPLICATIONS)
73 #define FLAG_FULL(ftype, ctype, nam, def, cmt)
74 #define FLAG_READONLY(ftype, ctype, nam, def, cmt)
75 #define DEFINE_implication(whenflag, thenflag) \
76  if (FLAG_##whenflag) FLAG_##thenflag = true;
77 
78 #else
79 #error No mode supplied when including flags.defs
80 #endif
81 
82 #ifdef FLAG_MODE_DECLARE
83 // Structure used to hold a collection of arguments to the JavaScript code.
84 #define JSARGUMENTS_INIT {{}}
85 struct JSArguments {
86 public:
87  inline int argc() const {
88  return static_cast<int>(storage_[0]);
89  }
90  inline const char** argv() const {
91  return reinterpret_cast<const char**>(storage_[1]);
92  }
93  inline const char*& operator[] (int idx) const {
94  return argv()[idx];
95  }
96  inline JSArguments& operator=(JSArguments args) {
97  set_argc(args.argc());
98  set_argv(args.argv());
99  return *this;
100  }
101  static JSArguments Create(int argc, const char** argv) {
102  JSArguments args;
103  args.set_argc(argc);
104  args.set_argv(argv);
105  return args;
106  }
107 private:
108  void set_argc(int argc) {
109  storage_[0] = argc;
110  }
111  void set_argv(const char** argv) {
112  storage_[1] = reinterpret_cast<AtomicWord>(argv);
113  }
114 public:
115  // Contains argc and argv. Unfortunately we have to store these two fields
116  // into a single one to avoid making the initialization macro (which would be
117  // "{ 0, NULL }") contain a coma.
118  AtomicWord storage_[2];
119 };
120 #endif
121 
122 #define DEFINE_bool(nam, def, cmt) FLAG(BOOL, bool, nam, def, cmt)
123 #define DEFINE_int(nam, def, cmt) FLAG(INT, int, nam, def, cmt)
124 #define DEFINE_float(nam, def, cmt) FLAG(FLOAT, double, nam, def, cmt)
125 #define DEFINE_string(nam, def, cmt) FLAG(STRING, const char*, nam, def, cmt)
126 #define DEFINE_args(nam, def, cmt) FLAG(ARGS, JSArguments, nam, def, cmt)
127 
128 //
129 // Flags in all modes.
130 //
131 #define FLAG FLAG_FULL
132 
133 // Flags for language modes and experimental language features.
134 DEFINE_bool(use_strict, false, "enforce strict mode")
135 DEFINE_bool(es5_readonly, true,
136  "activate correct semantics for inheriting readonliness")
137 DEFINE_bool(es52_globals, true,
138  "activate new semantics for global var declarations")
139 
140 DEFINE_bool(harmony_typeof, false, "enable harmony semantics for typeof")
141 DEFINE_bool(harmony_scoping, false, "enable harmony block scoping")
142 DEFINE_bool(harmony_modules, false,
143  "enable harmony modules (implies block scoping)")
144 DEFINE_bool(harmony_proxies, false, "enable harmony proxies")
145 DEFINE_bool(harmony_collections, false,
146  "enable harmony collections (sets, maps, and weak maps)")
147 DEFINE_bool(harmony, false, "enable all harmony features (except typeof)")
148 DEFINE_implication(harmony, harmony_scoping)
149 DEFINE_implication(harmony, harmony_modules)
150 DEFINE_implication(harmony, harmony_proxies)
151 DEFINE_implication(harmony, harmony_collections)
152 DEFINE_implication(harmony_modules, harmony_scoping)
153 
154 // Flags for experimental implementation features.
155 DEFINE_bool(packed_arrays, true, "optimizes arrays that have no holes")
156 DEFINE_bool(smi_only_arrays, true, "tracks arrays with only smi values")
157 DEFINE_bool(clever_optimizations,
158  true,
159  "Optimize object size, Array shift, DOM strings and string +")
160 
161 // Flags for data representation optimizations
162 DEFINE_bool(unbox_double_arrays, true, "automatically unbox arrays of doubles")
163 DEFINE_bool(string_slices, true, "use string slices")
164 
165 // Flags for Crankshaft.
166 DEFINE_bool(crankshaft, true, "use crankshaft")
167 DEFINE_string(hydrogen_filter, "", "optimization filter")
168 DEFINE_bool(use_range, true, "use hydrogen range analysis")
169 DEFINE_bool(eliminate_dead_phis, true, "eliminate dead phis")
170 DEFINE_bool(use_gvn, true, "use hydrogen global value numbering")
171 DEFINE_bool(use_canonicalizing, true, "use hydrogen instruction canonicalizing")
172 DEFINE_bool(use_inlining, true, "use function inlining")
173 DEFINE_int(max_inlined_source_size, 600,
174  "maximum source size in bytes considered for a single inlining")
175 DEFINE_int(max_inlined_nodes, 196,
176  "maximum number of AST nodes considered for a single inlining")
177 DEFINE_int(max_inlined_nodes_cumulative, 196,
178  "maximum cumulative number of AST nodes considered for inlining")
179 DEFINE_bool(loop_invariant_code_motion, true, "loop invariant code motion")
180 DEFINE_bool(collect_megamorphic_maps_from_stub_cache,
181  true,
182  "crankshaft harvests type feedback from stub cache")
183 DEFINE_bool(hydrogen_stats, false, "print statistics for hydrogen")
184 DEFINE_bool(trace_hydrogen, false, "trace generated hydrogen to file")
185 DEFINE_string(trace_phase, "Z", "trace generated IR for specified phases")
186 DEFINE_bool(trace_inlining, false, "trace inlining decisions")
187 DEFINE_bool(trace_alloc, false, "trace register allocator")
188 DEFINE_bool(trace_all_uses, false, "trace all use positions")
189 DEFINE_bool(trace_range, false, "trace range analysis")
190 DEFINE_bool(trace_gvn, false, "trace global value numbering")
191 DEFINE_bool(trace_representation, false, "trace representation types")
192 DEFINE_bool(stress_pointer_maps, false, "pointer map for every instruction")
193 DEFINE_bool(stress_environments, false, "environment for every instruction")
194 DEFINE_int(deopt_every_n_times,
195  0,
196  "deoptimize every n times a deopt point is passed")
197 DEFINE_bool(trap_on_deopt, false, "put a break point before deoptimizing")
198 DEFINE_bool(deoptimize_uncommon_cases, true, "deoptimize uncommon cases")
199 DEFINE_bool(polymorphic_inlining, true, "polymorphic inlining")
200 DEFINE_bool(use_osr, true, "use on-stack replacement")
201 DEFINE_bool(array_bounds_checks_elimination, true,
202  "perform array bounds checks elimination")
203 DEFINE_bool(array_index_dehoisting, true,
204  "perform array index dehoisting")
205 DEFINE_bool(dead_code_elimination, true, "use dead code elimination")
206 DEFINE_bool(trace_dead_code_elimination, false, "trace dead code elimination")
207 
208 DEFINE_bool(trace_osr, false, "trace on-stack replacement")
209 DEFINE_int(stress_runs, 0, "number of stress runs")
210 DEFINE_bool(optimize_closures, true, "optimize closures")
211 DEFINE_bool(lookup_sample_by_shared, true,
212  "when picking a function to optimize, watch for shared function "
213  "info, not JSFunction itself")
214 DEFINE_bool(cache_optimized_code, true,
215  "cache optimized code for closures")
216 DEFINE_bool(inline_construct, true, "inline constructor calls")
217 DEFINE_bool(inline_arguments, true, "inline functions with arguments object")
218 DEFINE_bool(inline_accessors, true, "inline JavaScript accessors")
219 DEFINE_int(loop_weight, 1, "loop weight for representation inference")
220 
221 DEFINE_bool(optimize_for_in, true,
222  "optimize functions containing for-in loops")
223 DEFINE_bool(opt_safe_uint32_operations, true,
224  "allow uint32 values on optimize frames if they are used only in"
225  "safe operations")
226 
227 DEFINE_bool(parallel_recompilation, false,
228  "optimizing hot functions asynchronously on a separate thread")
229 DEFINE_bool(trace_parallel_recompilation, false, "track parallel recompilation")
230 DEFINE_int(parallel_recompilation_queue_length, 2,
231  "the length of the parallel compilation queue")
232 
233 // Experimental profiler changes.
234 DEFINE_bool(experimental_profiler, true, "enable all profiler experiments")
235 DEFINE_bool(watch_ic_patching, false, "profiler considers IC stability")
236 DEFINE_int(frame_count, 1, "number of stack frames inspected by the profiler")
237 DEFINE_bool(self_optimization, false,
238  "primitive functions trigger their own optimization")
239 DEFINE_bool(direct_self_opt, false,
240  "call recompile stub directly when self-optimizing")
241 DEFINE_bool(retry_self_opt, false, "re-try self-optimization if it failed")
242 DEFINE_bool(count_based_interrupts, false,
243  "trigger profiler ticks based on counting instead of timing")
244 DEFINE_bool(interrupt_at_exit, false,
245  "insert an interrupt check at function exit")
246 DEFINE_bool(weighted_back_edges, false,
247  "weight back edges by jump distance for interrupt triggering")
248  // 0x1700 fits in the immediate field of an ARM instruction.
249 DEFINE_int(interrupt_budget, 0x1700,
250  "execution budget before interrupt is triggered")
251 DEFINE_int(type_info_threshold, 15,
252  "percentage of ICs that must have type info to allow optimization")
253 DEFINE_int(self_opt_count, 130, "call count before self-optimization")
254 
255 DEFINE_implication(experimental_profiler, watch_ic_patching)
256 DEFINE_implication(experimental_profiler, self_optimization)
257 // Not implying direct_self_opt here because it seems to be a bad idea.
258 DEFINE_implication(experimental_profiler, retry_self_opt)
259 DEFINE_implication(experimental_profiler, count_based_interrupts)
260 DEFINE_implication(experimental_profiler, interrupt_at_exit)
261 DEFINE_implication(experimental_profiler, weighted_back_edges)
262 
263 DEFINE_bool(trace_opt_verbose, false, "extra verbose compilation tracing")
264 DEFINE_implication(trace_opt_verbose, trace_opt)
265 
266 // assembler-ia32.cc / assembler-arm.cc / assembler-x64.cc
267 DEFINE_bool(debug_code, false,
268  "generate extra code (assertions) for debugging")
269 DEFINE_bool(code_comments, false, "emit comments in code disassembly")
270 DEFINE_bool(enable_sse2, true,
271  "enable use of SSE2 instructions if available")
272 DEFINE_bool(enable_sse3, true,
273  "enable use of SSE3 instructions if available")
274 DEFINE_bool(enable_sse4_1, true,
275  "enable use of SSE4.1 instructions if available")
276 DEFINE_bool(enable_cmov, true,
277  "enable use of CMOV instruction if available")
278 DEFINE_bool(enable_rdtsc, true,
279  "enable use of RDTSC instruction if available")
280 DEFINE_bool(enable_sahf, true,
281  "enable use of SAHF instruction if available (X64 only)")
282 DEFINE_bool(enable_vfp3, true,
283  "enable use of VFP3 instructions if available - this implies "
284  "enabling ARMv7 and VFP2 instructions (ARM only)")
285 DEFINE_bool(enable_vfp2, true,
286  "enable use of VFP2 instructions if available")
287 DEFINE_bool(enable_armv7, true,
288  "enable use of ARMv7 instructions if available (ARM only)")
289 DEFINE_bool(enable_sudiv, true,
290  "enable use of SDIV and UDIV instructions if available (ARM only)")
291 DEFINE_bool(enable_movw_movt, false,
292  "enable loading 32-bit constant by means of movw/movt "
293  "instruction pairs (ARM only)")
294 DEFINE_bool(enable_unaligned_accesses, true,
295  "enable unaligned accesses for ARMv7 (ARM only)")
296 DEFINE_bool(enable_fpu, true,
297  "enable use of MIPS FPU instructions if available (MIPS only)")
298 
299 // bootstrapper.cc
300 DEFINE_string(expose_natives_as, NULL, "expose natives in global object")
301 DEFINE_string(expose_debug_as, NULL, "expose debug in global object")
302 DEFINE_bool(expose_gc, false, "expose gc extension")
303 DEFINE_bool(expose_externalize_string, false,
304  "expose externalize string extension")
305 DEFINE_int(stack_trace_limit, 10, "number of stack frames to capture")
306 DEFINE_bool(builtins_in_stack_traces, false,
307  "show built-in functions in stack traces")
308 DEFINE_bool(disable_native_files, false, "disable builtin natives files")
309 
310 // builtins-ia32.cc
311 DEFINE_bool(inline_new, true, "use fast inline allocation")
312 
313 // checks.cc
314 DEFINE_bool(stack_trace_on_abort, true,
315  "print a stack trace if an assertion failure occurs")
316 
317 // codegen-ia32.cc / codegen-arm.cc
318 DEFINE_bool(trace, false, "trace function calls")
319 DEFINE_bool(mask_constants_with_cookie,
320  true,
321  "use random jit cookie to mask large constants")
322 
323 // codegen.cc
324 DEFINE_bool(lazy, true, "use lazy compilation")
325 DEFINE_bool(trace_opt, false, "trace lazy optimization")
326 DEFINE_bool(trace_opt_stats, false, "trace lazy optimization statistics")
327 DEFINE_bool(opt, true, "use adaptive optimizations")
328 DEFINE_bool(always_opt, false, "always try to optimize functions")
329 DEFINE_bool(prepare_always_opt, false, "prepare for turning on always opt")
330 DEFINE_bool(trace_deopt, false, "trace deoptimization")
331 
332 // compiler.cc
333 DEFINE_int(min_preparse_length, 1024,
334  "minimum length for automatic enable preparsing")
335 DEFINE_bool(always_full_compiler, false,
336  "try to use the dedicated run-once backend for all code")
337 DEFINE_int(max_opt_count, 10,
338  "maximum number of optimization attempts before giving up.")
339 
340 // compilation-cache.cc
341 DEFINE_bool(compilation_cache, true, "enable compilation cache")
342 
343 DEFINE_bool(cache_prototype_transitions, true, "cache prototype transitions")
344 
345 // debug.cc
346 DEFINE_bool(trace_debug_json, false, "trace debugging JSON request/response")
347 DEFINE_bool(debugger_auto_break, true,
348  "automatically set the debug break flag when debugger commands are "
349  "in the queue")
350 DEFINE_bool(enable_liveedit, true, "enable liveedit experimental feature")
351 DEFINE_bool(break_on_abort, true, "always cause a debug break before aborting")
352 
353 // execution.cc
354 // Slightly less than 1MB on 64-bit, since Windows' default stack size for
355 // the main execution thread is 1MB for both 32 and 64-bit.
356 DEFINE_int(stack_size, kPointerSize * 123,
357  "default size of stack region v8 is allowed to use (in kBytes)")
358 
359 // frames.cc
360 DEFINE_int(max_stack_trace_source_length, 300,
361  "maximum length of function source code printed in a stack trace.")
362 
363 // full-codegen.cc
364 DEFINE_bool(always_inline_smi_code, false,
365  "always inline smi code in non-opt code")
366 
367 // heap.cc
368 DEFINE_int(max_new_space_size, 0, "max size of the new generation (in kBytes)")
369 DEFINE_int(max_old_space_size, 0, "max size of the old generation (in Mbytes)")
370 DEFINE_int(max_executable_size, 0, "max size of executable memory (in Mbytes)")
371 DEFINE_bool(gc_global, false, "always perform global GCs")
372 DEFINE_int(gc_interval, -1, "garbage collect after <n> allocations")
373 DEFINE_bool(trace_gc, false,
374  "print one trace line following each garbage collection")
375 DEFINE_bool(trace_gc_nvp, false,
376  "print one detailed trace line in name=value format "
377  "after each garbage collection")
378 DEFINE_bool(trace_gc_ignore_scavenger, false,
379  "do not print trace line after scavenger collection")
380 DEFINE_bool(print_cumulative_gc_stat, false,
381  "print cumulative GC statistics in name=value format on exit")
382 DEFINE_bool(trace_gc_verbose, false,
383  "print more details following each garbage collection")
384 DEFINE_bool(trace_fragmentation, false,
385  "report fragmentation for old pointer and data pages")
386 DEFINE_bool(trace_external_memory, false,
387  "print amount of external allocated memory after each time "
388  "it is adjusted.")
389 DEFINE_bool(collect_maps, true,
390  "garbage collect maps from which no objects can be reached")
391 DEFINE_bool(flush_code, true,
392  "flush code that we expect not to use again before full gc")
393 DEFINE_bool(incremental_marking, true, "use incremental marking")
394 DEFINE_bool(incremental_marking_steps, true, "do incremental marking steps")
395 DEFINE_bool(trace_incremental_marking, false,
396  "trace progress of the incremental marking")
397 DEFINE_bool(track_gc_object_stats, false,
398  "track object counts and memory usage")
399 #ifdef VERIFY_HEAP
400 DEFINE_bool(verify_heap, false, "verify heap pointers before and after GC")
401 #endif
402 
403 // v8.cc
404 DEFINE_bool(use_idle_notification, true,
405  "Use idle notification to reduce memory footprint.")
406 // ic.cc
407 DEFINE_bool(use_ic, true, "use inline caching")
408 
409 #ifdef LIVE_OBJECT_LIST
410 // liveobjectlist.cc
411 DEFINE_string(lol_workdir, NULL, "path for lol temp files")
412 DEFINE_bool(verify_lol, false, "perform debugging verification for lol")
413 #endif
414 
415 // macro-assembler-ia32.cc
416 DEFINE_bool(native_code_counters, false,
417  "generate extra code for manipulating stats counters")
418 
419 // mark-compact.cc
420 DEFINE_bool(always_compact, false, "Perform compaction on every full GC")
421 DEFINE_bool(lazy_sweeping, true,
422  "Use lazy sweeping for old pointer and data spaces")
423 DEFINE_bool(never_compact, false,
424  "Never perform compaction on full GC - testing only")
425 DEFINE_bool(compact_code_space, true,
426  "Compact code space on full non-incremental collections")
427 DEFINE_bool(incremental_code_compaction, true,
428  "Compact code space on full incremental collections")
429 DEFINE_bool(cleanup_code_caches_at_gc, true,
430  "Flush inline caches prior to mark compact collection and "
431  "flush code caches in maps during mark compact cycle.")
432 DEFINE_int(random_seed, 0,
433  "Default seed for initializing random generator "
434  "(0, the default, means to use system random).")
435 
436 // objects.cc
437 DEFINE_bool(use_verbose_printer, true, "allows verbose printing")
438 
439 // parser.cc
440 DEFINE_bool(allow_natives_syntax, false, "allow natives syntax")
441 DEFINE_bool(trace_parse, false, "trace parsing and preparsing")
442 
443 // simulator-arm.cc and simulator-mips.cc
444 DEFINE_bool(trace_sim, false, "Trace simulator execution")
445 DEFINE_bool(check_icache, false,
446  "Check icache flushes in ARM and MIPS simulator")
447 DEFINE_int(stop_sim_at, 0, "Simulator stop after x number of instructions")
448 DEFINE_int(sim_stack_alignment, 8,
449  "Stack alingment in bytes in simulator (4 or 8, 8 is default)")
450 
451 // isolate.cc
452 DEFINE_bool(trace_exception, false,
453  "print stack trace when throwing exceptions")
454 DEFINE_bool(preallocate_message_memory, false,
455  "preallocate some memory to build stack traces.")
456 DEFINE_bool(randomize_hashes,
457  true,
458  "randomize hashes to avoid predictable hash collisions "
459  "(with snapshots this option cannot override the baked-in seed)")
460 DEFINE_int(hash_seed,
461  0,
462  "Fixed seed to use to hash property keys (0 means random)"
463  "(with snapshots this option cannot override the baked-in seed)")
464 
465 // v8.cc
466 DEFINE_bool(preemption, false,
467  "activate a 100ms timer that switches between V8 threads")
468 
469 // Regexp
470 DEFINE_bool(regexp_optimization, true, "generate optimized regexp code")
471 
472 // Testing flags test/cctest/test-{flags,api,serialization}.cc
473 DEFINE_bool(testing_bool_flag, true, "testing_bool_flag")
474 DEFINE_int(testing_int_flag, 13, "testing_int_flag")
475 DEFINE_float(testing_float_flag, 2.5, "float-flag")
476 DEFINE_string(testing_string_flag, "Hello, world!", "string-flag")
477 DEFINE_int(testing_prng_seed, 42, "Seed used for threading test randomness")
478 #ifdef WIN32
479 DEFINE_string(testing_serialization_file, "C:\\Windows\\Temp\\serdes",
480  "file in which to testing_serialize heap")
481 #else
482 DEFINE_string(testing_serialization_file, "/tmp/serdes",
483  "file in which to serialize heap")
484 #endif
485 
486 // mksnapshot.cc
487 DEFINE_string(extra_code, NULL, "A filename with extra code to be included in"
488  " the snapshot (mksnapshot only)")
489 
490 //
491 // Dev shell flags
492 //
493 
494 DEFINE_bool(help, false, "Print usage message, including flags, on console")
495 DEFINE_bool(dump_counters, false, "Dump counters on exit")
496 
497 #ifdef ENABLE_DEBUGGER_SUPPORT
498 DEFINE_bool(debugger, false, "Enable JavaScript debugger")
499 DEFINE_bool(remote_debugger, false, "Connect JavaScript debugger to the "
500  "debugger agent in another process")
501 DEFINE_bool(debugger_agent, false, "Enable debugger agent")
502 DEFINE_int(debugger_port, 5858, "Port to use for remote debugging")
503 #endif // ENABLE_DEBUGGER_SUPPORT
504 
505 DEFINE_string(map_counters, "", "Map counters to a file")
506 DEFINE_args(js_arguments, JSARGUMENTS_INIT,
507  "Pass all remaining arguments to the script. Alias for \"--\".")
508 
509 #if defined(WEBOS__)
510 DEFINE_bool(debug_compile_events, false, "Enable debugger compile events")
511 DEFINE_bool(debug_script_collected_events, false,
512  "Enable debugger script collected events")
513 #else
514 DEFINE_bool(debug_compile_events, true, "Enable debugger compile events")
515 DEFINE_bool(debug_script_collected_events, true,
516  "Enable debugger script collected events")
517 #endif
518 
519 
520 //
521 // GDB JIT integration flags.
522 //
523 
524 DEFINE_bool(gdbjit, false, "enable GDBJIT interface (disables compacting GC)")
525 DEFINE_bool(gdbjit_full, false, "enable GDBJIT interface for all code objects")
526 DEFINE_bool(gdbjit_dump, false, "dump elf objects with debug info to disk")
527 DEFINE_string(gdbjit_dump_filter, "",
528  "dump only objects containing this substring")
529 
530 // mark-compact.cc
531 DEFINE_bool(force_marking_deque_overflows, false,
532  "force overflows of marking deque by reducing it's size "
533  "to 64 words")
534 
535 DEFINE_bool(stress_compaction, false,
536  "stress the GC compactor to flush out bugs (implies "
537  "--force_marking_deque_overflows)")
538 
539 //
540 // Debug only flags
541 //
542 #undef FLAG
543 #ifdef DEBUG
544 #define FLAG FLAG_FULL
545 #else
546 #define FLAG FLAG_READONLY
547 #endif
548 
549 // checks.cc
550 DEFINE_bool(enable_slow_asserts, false,
551  "enable asserts that are slow to execute")
552 
553 // codegen-ia32.cc / codegen-arm.cc
554 DEFINE_bool(trace_codegen, false,
555  "print name of functions for which code is generated")
556 DEFINE_bool(print_source, false, "pretty print source code")
557 DEFINE_bool(print_builtin_source, false,
558  "pretty print source code for builtins")
559 DEFINE_bool(print_ast, false, "print source AST")
560 DEFINE_bool(print_builtin_ast, false, "print source AST for builtins")
561 DEFINE_string(stop_at, "", "function name where to insert a breakpoint")
562 
563 // compiler.cc
564 DEFINE_bool(print_builtin_scopes, false, "print scopes for builtins")
565 DEFINE_bool(print_scopes, false, "print scopes")
566 
567 // contexts.cc
568 DEFINE_bool(trace_contexts, false, "trace contexts operations")
569 
570 // heap.cc
571 DEFINE_bool(gc_greedy, false, "perform GC prior to some allocations")
572 DEFINE_bool(gc_verbose, false, "print stuff during garbage collection")
573 DEFINE_bool(heap_stats, false, "report heap statistics before and after GC")
574 DEFINE_bool(code_stats, false, "report code statistics after GC")
575 DEFINE_bool(verify_native_context_separation, false,
576  "verify that code holds on to at most one native context after GC")
577 DEFINE_bool(print_handles, false, "report handles after GC")
578 DEFINE_bool(print_global_handles, false, "report global handles after GC")
579 
580 // ic.cc
581 DEFINE_bool(trace_ic, false, "trace inline cache state transitions")
582 
583 // interface.cc
584 DEFINE_bool(print_interfaces, false, "print interfaces")
585 DEFINE_bool(print_interface_details, false, "print interface inference details")
586 DEFINE_int(print_interface_depth, 5, "depth for printing interfaces")
587 
588 // objects.cc
589 DEFINE_bool(trace_normalization,
590  false,
591  "prints when objects are turned into dictionaries.")
592 
593 // runtime.cc
594 DEFINE_bool(trace_lazy, false, "trace lazy compilation")
595 
596 // spaces.cc
597 DEFINE_bool(collect_heap_spill_statistics, false,
598  "report heap spill statistics along with heap_stats "
599  "(requires heap_stats)")
600 
601 DEFINE_bool(trace_isolates, false, "trace isolate state changes")
602 
603 // VM state
604 DEFINE_bool(log_state_changes, false, "Log state changes.")
605 
606 // Regexp
607 DEFINE_bool(regexp_possessive_quantifier,
608  false,
609  "enable possessive quantifier syntax for testing")
610 DEFINE_bool(trace_regexp_bytecodes, false, "trace regexp bytecode execution")
611 DEFINE_bool(trace_regexp_assembler,
612  false,
613  "trace regexp macro assembler calls.")
614 
615 //
616 // Logging and profiling flags
617 //
618 #undef FLAG
619 #define FLAG FLAG_FULL
620 
621 // log.cc
622 DEFINE_bool(log, false,
623  "Minimal logging (no API, code, GC, suspect, or handles samples).")
624 DEFINE_bool(log_all, false, "Log all events to the log file.")
625 DEFINE_bool(log_runtime, false, "Activate runtime system %Log call.")
626 DEFINE_bool(log_api, false, "Log API events to the log file.")
627 DEFINE_bool(log_code, false,
628  "Log code events to the log file without profiling.")
629 DEFINE_bool(log_gc, false,
630  "Log heap samples on garbage collection for the hp2ps tool.")
631 DEFINE_bool(log_handles, false, "Log global handle events.")
632 DEFINE_bool(log_snapshot_positions, false,
633  "log positions of (de)serialized objects in the snapshot.")
634 DEFINE_bool(log_suspect, false, "Log suspect operations.")
635 DEFINE_bool(prof, false,
636  "Log statistical profiling information (implies --log-code).")
637 DEFINE_bool(prof_auto, true,
638  "Used with --prof, starts profiling automatically")
639 DEFINE_bool(prof_lazy, false,
640  "Used with --prof, only does sampling and logging"
641  " when profiler is active (implies --noprof_auto).")
642 DEFINE_bool(prof_browser_mode, true,
643  "Used with --prof, turns on browser-compatible mode for profiling.")
644 DEFINE_bool(log_regexp, false, "Log regular expression execution.")
645 DEFINE_bool(sliding_state_window, false,
646  "Update sliding state window counters.")
647 DEFINE_string(logfile, "v8.log", "Specify the name of the log file.")
648 DEFINE_bool(ll_prof, false, "Enable low-level linux profiler.")
649 DEFINE_string(gc_fake_mmap, "/tmp/__v8_gc__",
650  "Specify the name of the file for fake gc mmap used in ll_prof")
651 
652 //
653 // Disassembler only flags
654 //
655 #undef FLAG
656 #ifdef ENABLE_DISASSEMBLER
657 #define FLAG FLAG_FULL
658 #else
659 #define FLAG FLAG_READONLY
660 #endif
661 
662 // elements.cc
663 DEFINE_bool(trace_elements_transitions, false, "trace elements transitions")
664 
665 // code-stubs.cc
666 DEFINE_bool(print_code_stubs, false, "print code stubs")
667 DEFINE_bool(test_secondary_stub_cache,
668  false,
669  "test secondary stub cache by disabling the primary one")
670 
671 DEFINE_bool(test_primary_stub_cache,
672  false,
673  "test primary stub cache by disabling the secondary one")
674 
675 // codegen-ia32.cc / codegen-arm.cc
676 DEFINE_bool(print_code, false, "print generated code")
677 DEFINE_bool(print_opt_code, false, "print optimized code")
678 DEFINE_bool(print_unopt_code, false, "print unoptimized code before "
679  "printing optimized code based on it")
680 DEFINE_bool(print_code_verbose, false, "print more information for code")
681 DEFINE_bool(print_builtin_code, false, "print generated code for builtins")
682 
683 #ifdef ENABLE_DISASSEMBLER
684 DEFINE_bool(print_all_code, false, "enable all flags related to printing code")
685 DEFINE_implication(print_all_code, print_code)
686 DEFINE_implication(print_all_code, print_opt_code)
687 DEFINE_implication(print_all_code, print_unopt_code)
688 DEFINE_implication(print_all_code, print_code_verbose)
689 DEFINE_implication(print_all_code, print_builtin_code)
690 DEFINE_implication(print_all_code, print_code_stubs)
691 DEFINE_implication(print_all_code, code_comments)
692 #ifdef DEBUG
693 DEFINE_implication(print_all_code, trace_codegen)
694 #endif
695 #endif
696 
697 // Cleanup...
698 #undef FLAG_FULL
699 #undef FLAG_READONLY
700 #undef FLAG
701 
702 #undef DEFINE_bool
703 #undef DEFINE_int
704 #undef DEFINE_string
705 #undef DEFINE_implication
706 
707 #undef FLAG_MODE_DECLARE
708 #undef FLAG_MODE_DEFINE
709 #undef FLAG_MODE_DEFINE_DEFAULTS
710 #undef FLAG_MODE_META
711 #undef FLAG_MODE_DEFINE_IMPLICATIONS
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash collisions(with snapshots this option cannot override the baked-in seed)") DEFINE_int(hash_seed
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new generation(in kBytes)") DEFINE_int(max_old_space_size
int random()
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in simulator(4 or 8, 8 is default)") DEFINE_bool(trace_exception
v8::Handle< v8::Value > Print(const v8::Arguments &args)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag float flag Seed used for threading test randomness A filename with extra code to be included in the Print usage including flags
unsigned int seed
Definition: test-strings.cc:18
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony modules(implies block scoping)") DEFINE_bool(harmony_proxies
#define DEFINE_float(nam, def, cmt)
Definition: flags.h:125
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property keys(0 means random)" "(with snapshots this option cannot override the baked-in seed)") DEFINE_bool(preemption
const int kPointerSize
Definition: globals.h:220
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if available(X64 only)") DEFINE_bool(enable_vfp3
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag float flag Seed used for threading test randomness A filename with extra code to be included in the Print usage message
intptr_t AtomicWord
Definition: atomicops.h:75
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction pairs(ARM only)") DEFINE_bool(enable_unaligned_accesses
#define DEFINE_int(nam, def, cmt)
Definition: flags.h:124
activate correct semantics for inheriting readonliness false
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra code(assertions) for debugging") DEFINE_bool(code_comments
#define DEFINE_args(nam, def, cmt)
Definition: flags.h:127
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable memory(in Mbytes)") DEFINE_bool(gc_global
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen Z
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping DEFINE_implication(harmony, harmony_modules) DEFINE_implication(harmony
void generate(MacroAssembler *masm, i::Vector< const char > string)
Definition: test-hashing.cc:52
#define GDBJIT(action)
Definition: gdb-jit.h:141
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag float flag Seed used for threading test randomness A filename with extra code to be included in the snapshot(mksnapshot only)") DEFINE_bool(help
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag float flag Seed used for threading test randomness A filename with extra code to be included in the Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out bugs(implies" "--force_marking_deque_overflows)") DEFINE_bool(enable_slow_asserts
#define DEFINE_string(nam, def, cmt)
Definition: flags.h:126
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random allows verbose printing trace parsing and preparsing Check icache flushes in ARM and MIPS simulator Stack alingment in bytes in print stack trace when throwing exceptions randomize hashes to avoid predictable hash Fixed seed to use to hash property activate a timer that switches between V8 threads testing_bool_flag float flag Seed used for threading test randomness A filename with extra code to be included in the Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT interface(disables compacting GC)") DEFINE_bool(gdbjit_full
#define DEFINE_bool(nam, def, cmt)
Definition: flags.h:123
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if NULL
#define JSARGUMENTS_INIT
Definition: flags.h:85
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony features(except typeof)") DEFINE_implication(harmony
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for ARMv7(ARM only)") DEFINE_bool(enable_fpu
Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions of(de) serialized objects in the snapshot.") DEFINE_bool(log_suspect
void Flush(FILE *out)
Definition: v8utils.cc:65
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 instructions(ARM only)") DEFINE_bool(enable_vfp2
void check(i::Vector< const char > string)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if expose natives in global object expose gc extension number of stack frames to capture disable builtin natives files print a stack trace if an assertion failure occurs use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations prepare for turning on always opt minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions automatically set the debug break flag when debugger commands are in the queue always cause a debug break before aborting maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print more details following each garbage collection print amount of external allocated memory after each time it is adjusted flush code that we expect not to use again before full gc do incremental marking steps track object counts and memory usage use caching Perform compaction on every full GC Never perform compaction on full GC testing only Compact code space on full incremental collections Default seed for initializing random generator(0, the default, means to use system random).") DEFINE_bool(use_verbose_printer
Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with prof
kPropertyAccessorsOffset kNamedPropertyHandlerOffset kInstanceTemplateOffset kAccessCheckInfoOffset kEvalFrominstructionsOffsetOffset kInstanceClassNameOffset flag
Definition: objects-inl.h:3923