2012-01-30 12:25:29 +00:00
|
|
|
// Copyright 2012 the V8 project authors. All rights reserved.
|
2008-09-12 10:19:33 +00:00
|
|
|
// Redistribution and use in source and binary forms, with or without
|
|
|
|
|
// modification, are permitted provided that the following conditions are
|
|
|
|
|
// met:
|
|
|
|
|
//
|
|
|
|
|
// * Redistributions of source code must retain the above copyright
|
|
|
|
|
// notice, this list of conditions and the following disclaimer.
|
|
|
|
|
// * Redistributions in binary form must reproduce the above
|
|
|
|
|
// copyright notice, this list of conditions and the following
|
|
|
|
|
// disclaimer in the documentation and/or other materials provided
|
|
|
|
|
// with the distribution.
|
|
|
|
|
// * Neither the name of Google Inc. nor the names of its
|
|
|
|
|
// contributors may be used to endorse or promote products derived
|
|
|
|
|
// from this software without specific prior written permission.
|
|
|
|
|
//
|
|
|
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
|
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
|
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
|
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
|
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
|
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
|
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
|
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
|
|
|
|
|
// This file defines all of the flags. It is separated into different section,
|
|
|
|
|
// for Debug, Release, Logging and Profiling, etc. To add a new flag, find the
|
|
|
|
|
// correct section, and use one of the DEFINE_ macros, without a trailing ';'.
|
|
|
|
|
//
|
|
|
|
|
// This include does not have a guard, because it is a template-style include,
|
|
|
|
|
// which can be included multiple times in different modes. It expects to have
|
|
|
|
|
// a mode defined before it's included. The modes are FLAG_MODE_... below:
|
|
|
|
|
|
|
|
|
|
// We want to declare the names of the variables for the header file. Normally
|
|
|
|
|
// this will just be an extern declaration, but for a readonly flag we let the
|
|
|
|
|
// compiler make better optimizations by giving it the value.
|
|
|
|
|
#if defined(FLAG_MODE_DECLARE)
|
|
|
|
|
#define FLAG_FULL(ftype, ctype, nam, def, cmt) \
|
|
|
|
|
extern ctype FLAG_##nam;
|
|
|
|
|
#define FLAG_READONLY(ftype, ctype, nam, def, cmt) \
|
|
|
|
|
static ctype const FLAG_##nam = def;
|
2011-12-15 17:00:27 +00:00
|
|
|
#define DEFINE_implication(whenflag, thenflag)
|
2008-09-12 10:19:33 +00:00
|
|
|
|
|
|
|
|
// We want to supply the actual storage and value for the flag variable in the
|
|
|
|
|
// .cc file. We only do this for writable flags.
|
|
|
|
|
#elif defined(FLAG_MODE_DEFINE)
|
|
|
|
|
#define FLAG_FULL(ftype, ctype, nam, def, cmt) \
|
|
|
|
|
ctype FLAG_##nam = def;
|
|
|
|
|
#define FLAG_READONLY(ftype, ctype, nam, def, cmt)
|
2011-12-15 17:00:27 +00:00
|
|
|
#define DEFINE_implication(whenflag, thenflag)
|
2008-09-12 10:19:33 +00:00
|
|
|
|
|
|
|
|
// We need to define all of our default values so that the Flag structure can
|
|
|
|
|
// access them by pointer. These are just used internally inside of one .cc,
|
|
|
|
|
// for MODE_META, so there is no impact on the flags interface.
|
|
|
|
|
#elif defined(FLAG_MODE_DEFINE_DEFAULTS)
|
|
|
|
|
#define FLAG_FULL(ftype, ctype, nam, def, cmt) \
|
|
|
|
|
static ctype const FLAGDEFAULT_##nam = def;
|
|
|
|
|
#define FLAG_READONLY(ftype, ctype, nam, def, cmt)
|
2011-12-15 17:00:27 +00:00
|
|
|
#define DEFINE_implication(whenflag, thenflag)
|
2008-09-12 10:19:33 +00:00
|
|
|
|
|
|
|
|
// We want to write entries into our meta data table, for internal parsing and
|
|
|
|
|
// printing / etc in the flag parser code. We only do this for writable flags.
|
|
|
|
|
#elif defined(FLAG_MODE_META)
|
|
|
|
|
#define FLAG_FULL(ftype, ctype, nam, def, cmt) \
|
2009-03-27 00:24:49 +00:00
|
|
|
{ Flag::TYPE_##ftype, #nam, &FLAG_##nam, &FLAGDEFAULT_##nam, cmt, false },
|
2008-09-12 10:19:33 +00:00
|
|
|
#define FLAG_READONLY(ftype, ctype, nam, def, cmt)
|
2011-12-15 17:00:27 +00:00
|
|
|
#define DEFINE_implication(whenflag, thenflag)
|
|
|
|
|
|
|
|
|
|
// We produce the code to set flags when it is implied by another flag.
|
|
|
|
|
#elif defined(FLAG_MODE_DEFINE_IMPLICATIONS)
|
|
|
|
|
#define FLAG_FULL(ftype, ctype, nam, def, cmt)
|
|
|
|
|
#define FLAG_READONLY(ftype, ctype, nam, def, cmt)
|
|
|
|
|
#define DEFINE_implication(whenflag, thenflag) \
|
|
|
|
|
if (FLAG_##whenflag) FLAG_##thenflag = true;
|
2008-09-12 10:19:33 +00:00
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
#error No mode supplied when including flags.defs
|
|
|
|
|
#endif
|
|
|
|
|
|
2008-11-11 14:16:24 +00:00
|
|
|
#ifdef FLAG_MODE_DECLARE
|
|
|
|
|
// Structure used to hold a collection of arguments to the JavaScript code.
|
2012-03-12 13:56:56 +00:00
|
|
|
#define JSARGUMENTS_INIT {{}}
|
2008-11-11 14:16:24 +00:00
|
|
|
struct JSArguments {
|
|
|
|
|
public:
|
2012-03-12 13:56:56 +00:00
|
|
|
inline int argc() const {
|
|
|
|
|
return static_cast<int>(storage_[0]);
|
|
|
|
|
}
|
|
|
|
|
inline const char** argv() const {
|
|
|
|
|
return reinterpret_cast<const char**>(storage_[1]);
|
|
|
|
|
}
|
|
|
|
|
inline const char*& operator[] (int idx) const {
|
|
|
|
|
return argv()[idx];
|
|
|
|
|
}
|
|
|
|
|
inline JSArguments& operator=(JSArguments args) {
|
|
|
|
|
set_argc(args.argc());
|
|
|
|
|
set_argv(args.argv());
|
|
|
|
|
return *this;
|
|
|
|
|
}
|
|
|
|
|
static JSArguments Create(int argc, const char** argv) {
|
|
|
|
|
JSArguments args;
|
|
|
|
|
args.set_argc(argc);
|
|
|
|
|
args.set_argv(argv);
|
|
|
|
|
return args;
|
|
|
|
|
}
|
2008-11-11 14:16:24 +00:00
|
|
|
private:
|
2012-03-12 13:56:56 +00:00
|
|
|
void set_argc(int argc) {
|
|
|
|
|
storage_[0] = argc;
|
|
|
|
|
}
|
|
|
|
|
void set_argv(const char** argv) {
|
|
|
|
|
storage_[1] = reinterpret_cast<AtomicWord>(argv);
|
|
|
|
|
}
|
|
|
|
|
public:
|
|
|
|
|
// Contains argc and argv. Unfortunately we have to store these two fields
|
|
|
|
|
// into a single one to avoid making the initialization macro (which would be
|
|
|
|
|
// "{ 0, NULL }") contain a coma.
|
|
|
|
|
AtomicWord storage_[2];
|
2008-11-11 14:16:24 +00:00
|
|
|
};
|
|
|
|
|
#endif
|
|
|
|
|
|
2013-04-16 14:39:48 +00:00
|
|
|
#if (defined CAN_USE_VFP3_INSTRUCTIONS) || !(defined ARM_TEST)
|
|
|
|
|
# define ENABLE_VFP3_DEFAULT true
|
|
|
|
|
#else
|
|
|
|
|
# define ENABLE_VFP3_DEFAULT false
|
|
|
|
|
#endif
|
|
|
|
|
#if (defined CAN_USE_ARMV7_INSTRUCTIONS) || !(defined ARM_TEST)
|
|
|
|
|
# define ENABLE_ARMV7_DEFAULT true
|
|
|
|
|
#else
|
|
|
|
|
# define ENABLE_ARMV7_DEFAULT false
|
|
|
|
|
#endif
|
|
|
|
|
#if (defined CAN_USE_VFP32DREGS) || !(defined ARM_TEST)
|
|
|
|
|
# define ENABLE_32DREGS_DEFAULT true
|
|
|
|
|
#else
|
|
|
|
|
# define ENABLE_32DREGS_DEFAULT false
|
|
|
|
|
#endif
|
|
|
|
|
|
2008-09-12 10:19:33 +00:00
|
|
|
#define DEFINE_bool(nam, def, cmt) FLAG(BOOL, bool, nam, def, cmt)
|
|
|
|
|
#define DEFINE_int(nam, def, cmt) FLAG(INT, int, nam, def, cmt)
|
|
|
|
|
#define DEFINE_float(nam, def, cmt) FLAG(FLOAT, double, nam, def, cmt)
|
|
|
|
|
#define DEFINE_string(nam, def, cmt) FLAG(STRING, const char*, nam, def, cmt)
|
2008-11-11 14:16:24 +00:00
|
|
|
#define DEFINE_args(nam, def, cmt) FLAG(ARGS, JSArguments, nam, def, cmt)
|
2008-09-12 10:19:33 +00:00
|
|
|
|
|
|
|
|
//
|
|
|
|
|
// Flags in all modes.
|
|
|
|
|
//
|
|
|
|
|
#define FLAG FLAG_FULL
|
|
|
|
|
|
2012-02-20 13:48:24 +00:00
|
|
|
// Flags for language modes and experimental language features.
|
|
|
|
|
DEFINE_bool(use_strict, false, "enforce strict mode")
|
2012-08-31 09:12:31 +00:00
|
|
|
DEFINE_bool(es5_readonly, true,
|
2012-06-05 12:39:07 +00:00
|
|
|
"activate correct semantics for inheriting readonliness")
|
2012-07-11 09:39:44 +00:00
|
|
|
DEFINE_bool(es52_globals, true,
|
2012-04-20 13:35:09 +00:00
|
|
|
"activate new semantics for global var declarations")
|
2012-02-20 13:48:24 +00:00
|
|
|
|
2011-08-10 12:12:06 +00:00
|
|
|
DEFINE_bool(harmony_typeof, false, "enable harmony semantics for typeof")
|
2011-10-12 12:23:06 +00:00
|
|
|
DEFINE_bool(harmony_scoping, false, "enable harmony block scoping")
|
2012-02-20 14:02:59 +00:00
|
|
|
DEFINE_bool(harmony_modules, false,
|
|
|
|
|
"enable harmony modules (implies block scoping)")
|
2013-03-01 13:28:55 +00:00
|
|
|
DEFINE_bool(harmony_symbols, false,
|
|
|
|
|
"enable harmony symbols (a.k.a. private names)")
|
2011-04-15 12:31:03 +00:00
|
|
|
DEFINE_bool(harmony_proxies, false, "enable harmony proxies")
|
2011-10-25 14:14:56 +00:00
|
|
|
DEFINE_bool(harmony_collections, false,
|
|
|
|
|
"enable harmony collections (sets, maps, and weak maps)")
|
2012-11-06 12:32:36 +00:00
|
|
|
DEFINE_bool(harmony_observation, false,
|
2012-10-25 14:53:26 +00:00
|
|
|
"enable harmony object observation (implies harmony collections")
|
2013-03-28 12:50:18 +00:00
|
|
|
DEFINE_bool(harmony_typed_arrays, false,
|
|
|
|
|
"enable harmony typed arrays")
|
2013-05-06 16:19:27 +00:00
|
|
|
DEFINE_bool(harmony_array_buffer, false,
|
|
|
|
|
"enable harmony array buffer")
|
|
|
|
|
DEFINE_implication(harmony_typed_arrays, harmony_array_buffer)
|
2013-04-02 17:34:59 +00:00
|
|
|
DEFINE_bool(harmony_generators, false, "enable harmony generators")
|
2012-01-27 13:07:39 +00:00
|
|
|
DEFINE_bool(harmony, false, "enable all harmony features (except typeof)")
|
2011-12-15 17:00:27 +00:00
|
|
|
DEFINE_implication(harmony, harmony_scoping)
|
2012-02-08 10:53:58 +00:00
|
|
|
DEFINE_implication(harmony, harmony_modules)
|
2013-03-01 13:28:55 +00:00
|
|
|
DEFINE_implication(harmony, harmony_symbols)
|
2011-12-15 17:00:27 +00:00
|
|
|
DEFINE_implication(harmony, harmony_proxies)
|
|
|
|
|
DEFINE_implication(harmony, harmony_collections)
|
2012-11-06 12:32:36 +00:00
|
|
|
DEFINE_implication(harmony, harmony_observation)
|
2013-04-02 17:34:59 +00:00
|
|
|
DEFINE_implication(harmony, harmony_generators)
|
2012-02-20 14:02:59 +00:00
|
|
|
DEFINE_implication(harmony_modules, harmony_scoping)
|
2012-11-06 12:32:36 +00:00
|
|
|
DEFINE_implication(harmony_observation, harmony_collections)
|
2013-04-29 11:18:27 +00:00
|
|
|
// TODO[dslomov] add harmony => harmony_typed_arrays
|
2011-04-15 12:31:03 +00:00
|
|
|
|
2011-06-09 10:03:35 +00:00
|
|
|
// Flags for experimental implementation features.
|
2012-07-23 15:01:25 +00:00
|
|
|
DEFINE_bool(packed_arrays, true, "optimizes arrays that have no holes")
|
2012-02-16 15:47:36 +00:00
|
|
|
DEFINE_bool(smi_only_arrays, true, "tracks arrays with only smi values")
|
2013-02-04 12:01:59 +00:00
|
|
|
DEFINE_bool(compiled_transitions, false, "use optimizing compiler to "
|
|
|
|
|
"generate array elements transition stubs")
|
2013-04-09 13:44:22 +00:00
|
|
|
DEFINE_bool(compiled_keyed_stores, true, "use optimizing compiler to "
|
2013-03-20 10:37:13 +00:00
|
|
|
"generate keyed store stubs")
|
2011-10-11 11:35:04 +00:00
|
|
|
DEFINE_bool(clever_optimizations,
|
|
|
|
|
true,
|
|
|
|
|
"Optimize object size, Array shift, DOM strings and string +")
|
2013-05-23 08:17:03 +00:00
|
|
|
DEFINE_bool(pretenuring, true, "allocate objects in old space")
|
2013-06-04 13:20:13 +00:00
|
|
|
// TODO(hpayer): We will remove this flag as soon as we have pretenuring
|
|
|
|
|
// support for specific allocation sites.
|
|
|
|
|
DEFINE_bool(pretenuring_call_new, false, "pretenure call new")
|
2013-05-10 09:12:52 +00:00
|
|
|
DEFINE_bool(track_fields, true, "track fields with only smi values")
|
|
|
|
|
DEFINE_bool(track_double_fields, true, "track fields with double values")
|
2013-05-10 17:17:50 +00:00
|
|
|
DEFINE_bool(track_heap_object_fields, true, "track fields with heap values")
|
2013-04-26 15:30:41 +00:00
|
|
|
DEFINE_implication(track_double_fields, track_fields)
|
2013-05-10 17:17:50 +00:00
|
|
|
DEFINE_implication(track_heap_object_fields, track_fields)
|
2011-10-11 11:35:04 +00:00
|
|
|
|
2012-01-30 12:25:29 +00:00
|
|
|
// Flags for data representation optimizations
|
|
|
|
|
DEFINE_bool(unbox_double_arrays, true, "automatically unbox arrays of doubles")
|
|
|
|
|
DEFINE_bool(string_slices, true, "use string slices")
|
|
|
|
|
|
2010-12-07 11:31:57 +00:00
|
|
|
// Flags for Crankshaft.
|
2011-10-28 08:14:46 +00:00
|
|
|
DEFINE_bool(crankshaft, true, "use crankshaft")
|
2012-03-14 09:45:17 +00:00
|
|
|
DEFINE_string(hydrogen_filter, "", "optimization filter")
|
2010-12-07 11:31:57 +00:00
|
|
|
DEFINE_bool(use_range, true, "use hydrogen range analysis")
|
|
|
|
|
DEFINE_bool(use_gvn, true, "use hydrogen global value numbering")
|
|
|
|
|
DEFINE_bool(use_canonicalizing, true, "use hydrogen instruction canonicalizing")
|
|
|
|
|
DEFINE_bool(use_inlining, true, "use function inlining")
|
2012-04-20 10:42:12 +00:00
|
|
|
DEFINE_int(max_inlined_source_size, 600,
|
|
|
|
|
"maximum source size in bytes considered for a single inlining")
|
|
|
|
|
DEFINE_int(max_inlined_nodes, 196,
|
|
|
|
|
"maximum number of AST nodes considered for a single inlining")
|
|
|
|
|
DEFINE_int(max_inlined_nodes_cumulative, 196,
|
|
|
|
|
"maximum cumulative number of AST nodes considered for inlining")
|
2010-12-07 11:31:57 +00:00
|
|
|
DEFINE_bool(loop_invariant_code_motion, true, "loop invariant code motion")
|
2012-11-26 13:12:35 +00:00
|
|
|
DEFINE_bool(fast_math, true, "faster (but maybe less accurate) math functions")
|
2011-11-18 14:08:57 +00:00
|
|
|
DEFINE_bool(collect_megamorphic_maps_from_stub_cache,
|
|
|
|
|
true,
|
|
|
|
|
"crankshaft harvests type feedback from stub cache")
|
2011-03-10 13:26:51 +00:00
|
|
|
DEFINE_bool(hydrogen_stats, false, "print statistics for hydrogen")
|
2010-12-07 11:31:57 +00:00
|
|
|
DEFINE_bool(trace_hydrogen, false, "trace generated hydrogen to file")
|
2012-03-01 11:33:37 +00:00
|
|
|
DEFINE_string(trace_phase, "Z", "trace generated IR for specified phases")
|
2010-12-07 11:31:57 +00:00
|
|
|
DEFINE_bool(trace_inlining, false, "trace inlining decisions")
|
|
|
|
|
DEFINE_bool(trace_alloc, false, "trace register allocator")
|
2011-02-23 15:25:04 +00:00
|
|
|
DEFINE_bool(trace_all_uses, false, "trace all use positions")
|
2010-12-07 11:31:57 +00:00
|
|
|
DEFINE_bool(trace_range, false, "trace range analysis")
|
|
|
|
|
DEFINE_bool(trace_gvn, false, "trace global value numbering")
|
|
|
|
|
DEFINE_bool(trace_representation, false, "trace representation types")
|
2013-01-17 08:41:27 +00:00
|
|
|
DEFINE_bool(trace_track_allocation_sites, false,
|
|
|
|
|
"trace the tracking of allocation sites")
|
2013-05-08 15:02:08 +00:00
|
|
|
DEFINE_bool(trace_migration, false, "trace object migration")
|
|
|
|
|
DEFINE_bool(trace_generalization, false, "trace map generalization")
|
2010-12-07 11:31:57 +00:00
|
|
|
DEFINE_bool(stress_pointer_maps, false, "pointer map for every instruction")
|
2012-07-09 12:06:07 +00:00
|
|
|
DEFINE_bool(stress_environments, false, "environment for every instruction")
|
2010-12-07 11:31:57 +00:00
|
|
|
DEFINE_int(deopt_every_n_times,
|
|
|
|
|
0,
|
|
|
|
|
"deoptimize every n times a deopt point is passed")
|
2013-04-23 15:21:11 +00:00
|
|
|
DEFINE_int(deopt_every_n_garbage_collections,
|
|
|
|
|
0,
|
|
|
|
|
"deoptimize every n garbage collections")
|
2010-12-07 11:31:57 +00:00
|
|
|
DEFINE_bool(trap_on_deopt, false, "put a break point before deoptimizing")
|
|
|
|
|
DEFINE_bool(deoptimize_uncommon_cases, true, "deoptimize uncommon cases")
|
|
|
|
|
DEFINE_bool(polymorphic_inlining, true, "polymorphic inlining")
|
2011-02-15 08:47:14 +00:00
|
|
|
DEFINE_bool(use_osr, true, "use on-stack replacement")
|
2013-02-01 10:16:16 +00:00
|
|
|
DEFINE_bool(idefs, false, "use informative definitions")
|
2012-09-12 17:00:25 +00:00
|
|
|
DEFINE_bool(array_bounds_checks_elimination, true,
|
2012-04-25 14:32:27 +00:00
|
|
|
"perform array bounds checks elimination")
|
2012-09-12 17:00:25 +00:00
|
|
|
DEFINE_bool(array_index_dehoisting, true,
|
2012-05-21 07:59:50 +00:00
|
|
|
"perform array index dehoisting")
|
2012-10-11 10:52:58 +00:00
|
|
|
DEFINE_bool(dead_code_elimination, true, "use dead code elimination")
|
2013-02-21 11:40:37 +00:00
|
|
|
DEFINE_bool(fold_constants, true, "use constant folding")
|
2012-10-11 10:52:58 +00:00
|
|
|
DEFINE_bool(trace_dead_code_elimination, false, "trace dead code elimination")
|
2013-01-21 14:11:25 +00:00
|
|
|
DEFINE_bool(unreachable_code_elimination, false,
|
|
|
|
|
"eliminate unreachable code (hidden behind soft deopts)")
|
2013-01-08 09:03:16 +00:00
|
|
|
DEFINE_bool(track_allocation_sites, true,
|
|
|
|
|
"Use allocation site info to reduce transitions")
|
2013-06-03 14:46:23 +00:00
|
|
|
DEFINE_bool(optimize_constructed_arrays, true,
|
2013-03-01 16:06:34 +00:00
|
|
|
"Use allocation site info on constructed arrays")
|
2010-12-07 11:31:57 +00:00
|
|
|
DEFINE_bool(trace_osr, false, "trace on-stack replacement")
|
2010-12-16 13:24:23 +00:00
|
|
|
DEFINE_int(stress_runs, 0, "number of stress runs")
|
2011-01-17 08:11:03 +00:00
|
|
|
DEFINE_bool(optimize_closures, true, "optimize closures")
|
2012-06-14 14:06:22 +00:00
|
|
|
DEFINE_bool(lookup_sample_by_shared, true,
|
|
|
|
|
"when picking a function to optimize, watch for shared function "
|
|
|
|
|
"info, not JSFunction itself")
|
2012-06-22 13:55:15 +00:00
|
|
|
DEFINE_bool(cache_optimized_code, true,
|
2012-06-14 14:06:22 +00:00
|
|
|
"cache optimized code for closures")
|
2013-05-16 08:39:24 +00:00
|
|
|
DEFINE_bool(flush_optimized_code_cache, true,
|
|
|
|
|
"flushes the cache of optimized code for closures on every GC")
|
2012-03-19 07:51:37 +00:00
|
|
|
DEFINE_bool(inline_construct, true, "inline constructor calls")
|
2012-03-12 12:49:41 +00:00
|
|
|
DEFINE_bool(inline_arguments, true, "inline functions with arguments object")
|
2012-09-07 09:01:54 +00:00
|
|
|
DEFINE_bool(inline_accessors, true, "inline JavaScript accessors")
|
2012-02-01 08:49:18 +00:00
|
|
|
DEFINE_int(loop_weight, 1, "loop weight for representation inference")
|
2010-12-07 11:31:57 +00:00
|
|
|
|
2012-02-27 14:37:27 +00:00
|
|
|
DEFINE_bool(optimize_for_in, true,
|
2012-02-27 10:43:57 +00:00
|
|
|
"optimize functions containing for-in loops")
|
2012-08-22 15:44:17 +00:00
|
|
|
DEFINE_bool(opt_safe_uint32_operations, true,
|
2012-11-16 10:57:50 +00:00
|
|
|
"allow uint32 values on optimize frames if they are used only in "
|
2012-08-22 15:44:17 +00:00
|
|
|
"safe operations")
|
2012-02-27 10:43:57 +00:00
|
|
|
|
2012-07-19 18:58:23 +00:00
|
|
|
DEFINE_bool(parallel_recompilation, false,
|
|
|
|
|
"optimizing hot functions asynchronously on a separate thread")
|
|
|
|
|
DEFINE_bool(trace_parallel_recompilation, false, "track parallel recompilation")
|
2013-03-12 18:03:18 +00:00
|
|
|
DEFINE_int(parallel_recompilation_queue_length, 3,
|
2012-07-19 18:58:23 +00:00
|
|
|
"the length of the parallel compilation queue")
|
2013-03-05 16:22:08 +00:00
|
|
|
DEFINE_int(parallel_recompilation_delay, 0,
|
|
|
|
|
"artificial compilation delay in ms")
|
2013-02-20 11:49:54 +00:00
|
|
|
DEFINE_bool(omit_prototype_checks_for_leaf_maps, true,
|
|
|
|
|
"do not emit prototype checks if all prototypes have leaf maps, "
|
|
|
|
|
"deoptimize the optimized code if the layout of the maps changes.")
|
2012-07-19 18:58:23 +00:00
|
|
|
|
2012-02-09 13:30:01 +00:00
|
|
|
// Experimental profiler changes.
|
2012-03-19 17:29:25 +00:00
|
|
|
DEFINE_bool(experimental_profiler, true, "enable all profiler experiments")
|
2012-02-09 13:30:01 +00:00
|
|
|
DEFINE_bool(watch_ic_patching, false, "profiler considers IC stability")
|
2012-03-09 17:55:54 +00:00
|
|
|
DEFINE_int(frame_count, 1, "number of stack frames inspected by the profiler")
|
2012-02-09 13:30:01 +00:00
|
|
|
DEFINE_bool(self_optimization, false,
|
|
|
|
|
"primitive functions trigger their own optimization")
|
2012-03-09 16:23:06 +00:00
|
|
|
DEFINE_bool(direct_self_opt, false,
|
|
|
|
|
"call recompile stub directly when self-optimizing")
|
2012-03-09 17:55:54 +00:00
|
|
|
DEFINE_bool(retry_self_opt, false, "re-try self-optimization if it failed")
|
2012-02-22 15:18:29 +00:00
|
|
|
DEFINE_bool(interrupt_at_exit, false,
|
|
|
|
|
"insert an interrupt check at function exit")
|
2012-02-14 14:00:31 +00:00
|
|
|
DEFINE_bool(weighted_back_edges, false,
|
|
|
|
|
"weight back edges by jump distance for interrupt triggering")
|
2012-08-10 12:24:06 +00:00
|
|
|
// 0x1700 fits in the immediate field of an ARM instruction.
|
|
|
|
|
DEFINE_int(interrupt_budget, 0x1700,
|
2012-02-14 14:00:31 +00:00
|
|
|
"execution budget before interrupt is triggered")
|
2012-03-13 11:38:37 +00:00
|
|
|
DEFINE_int(type_info_threshold, 15,
|
2012-02-20 12:57:23 +00:00
|
|
|
"percentage of ICs that must have type info to allow optimization")
|
2012-03-09 17:55:54 +00:00
|
|
|
DEFINE_int(self_opt_count, 130, "call count before self-optimization")
|
2012-02-09 13:30:01 +00:00
|
|
|
|
|
|
|
|
DEFINE_implication(experimental_profiler, watch_ic_patching)
|
|
|
|
|
DEFINE_implication(experimental_profiler, self_optimization)
|
2012-03-09 17:55:54 +00:00
|
|
|
// Not implying direct_self_opt here because it seems to be a bad idea.
|
|
|
|
|
DEFINE_implication(experimental_profiler, retry_self_opt)
|
2012-02-22 15:18:29 +00:00
|
|
|
DEFINE_implication(experimental_profiler, interrupt_at_exit)
|
2012-02-14 14:28:37 +00:00
|
|
|
DEFINE_implication(experimental_profiler, weighted_back_edges)
|
2012-02-09 10:19:46 +00:00
|
|
|
|
2012-02-20 12:57:23 +00:00
|
|
|
DEFINE_bool(trace_opt_verbose, false, "extra verbose compilation tracing")
|
|
|
|
|
DEFINE_implication(trace_opt_verbose, trace_opt)
|
|
|
|
|
|
2009-10-08 14:27:46 +00:00
|
|
|
// assembler-ia32.cc / assembler-arm.cc / assembler-x64.cc
|
2008-09-12 10:19:33 +00:00
|
|
|
DEFINE_bool(debug_code, false,
|
2010-12-07 11:31:57 +00:00
|
|
|
"generate extra code (assertions) for debugging")
|
|
|
|
|
DEFINE_bool(code_comments, false, "emit comments in code disassembly")
|
2009-10-08 14:27:46 +00:00
|
|
|
DEFINE_bool(enable_sse2, true,
|
|
|
|
|
"enable use of SSE2 instructions if available")
|
|
|
|
|
DEFINE_bool(enable_sse3, true,
|
|
|
|
|
"enable use of SSE3 instructions if available")
|
2010-09-28 14:56:36 +00:00
|
|
|
DEFINE_bool(enable_sse4_1, true,
|
|
|
|
|
"enable use of SSE4.1 instructions if available")
|
2009-10-08 14:27:46 +00:00
|
|
|
DEFINE_bool(enable_cmov, true,
|
|
|
|
|
"enable use of CMOV instruction if available")
|
|
|
|
|
DEFINE_bool(enable_rdtsc, true,
|
|
|
|
|
"enable use of RDTSC instruction if available")
|
|
|
|
|
DEFINE_bool(enable_sahf, true,
|
|
|
|
|
"enable use of SAHF instruction if available (X64 only)")
|
2013-04-16 14:39:48 +00:00
|
|
|
DEFINE_bool(enable_vfp3, ENABLE_VFP3_DEFAULT,
|
2013-04-07 04:34:20 +00:00
|
|
|
"enable use of VFP3 instructions if available")
|
2013-04-16 14:39:48 +00:00
|
|
|
DEFINE_bool(enable_armv7, ENABLE_ARMV7_DEFAULT,
|
2010-02-05 08:46:41 +00:00
|
|
|
"enable use of ARMv7 instructions if available (ARM only)")
|
2012-10-01 21:27:33 +00:00
|
|
|
DEFINE_bool(enable_sudiv, true,
|
|
|
|
|
"enable use of SDIV and UDIV instructions if available (ARM only)")
|
2012-10-18 12:21:42 +00:00
|
|
|
DEFINE_bool(enable_movw_movt, false,
|
|
|
|
|
"enable loading 32-bit constant by means of movw/movt "
|
|
|
|
|
"instruction pairs (ARM only)")
|
2012-10-15 15:19:36 +00:00
|
|
|
DEFINE_bool(enable_unaligned_accesses, true,
|
|
|
|
|
"enable unaligned accesses for ARMv7 (ARM only)")
|
2013-04-16 14:39:48 +00:00
|
|
|
DEFINE_bool(enable_32dregs, ENABLE_32DREGS_DEFAULT,
|
2013-01-23 16:29:48 +00:00
|
|
|
"enable use of d16-d31 registers on ARM - this requires VFP3")
|
2012-12-28 13:34:15 +00:00
|
|
|
DEFINE_bool(enable_vldr_imm, false,
|
|
|
|
|
"enable use of constant pools for double immediate (ARM only)")
|
2008-09-12 10:19:33 +00:00
|
|
|
|
|
|
|
|
// bootstrapper.cc
|
|
|
|
|
DEFINE_string(expose_natives_as, NULL, "expose natives in global object")
|
|
|
|
|
DEFINE_string(expose_debug_as, NULL, "expose debug in global object")
|
|
|
|
|
DEFINE_bool(expose_gc, false, "expose gc extension")
|
2013-04-23 16:30:51 +00:00
|
|
|
DEFINE_string(expose_gc_as,
|
|
|
|
|
NULL,
|
|
|
|
|
"expose gc extension under the specified name")
|
|
|
|
|
DEFINE_implication(expose_gc_as, expose_gc)
|
2010-06-17 16:19:28 +00:00
|
|
|
DEFINE_bool(expose_externalize_string, false,
|
|
|
|
|
"expose externalize string extension")
|
2009-07-02 12:26:31 +00:00
|
|
|
DEFINE_int(stack_trace_limit, 10, "number of stack frames to capture")
|
2011-10-20 12:31:33 +00:00
|
|
|
DEFINE_bool(builtins_in_stack_traces, false,
|
|
|
|
|
"show built-in functions in stack traces")
|
2010-03-23 15:04:45 +00:00
|
|
|
DEFINE_bool(disable_native_files, false, "disable builtin natives files")
|
2008-09-12 10:19:33 +00:00
|
|
|
|
|
|
|
|
// builtins-ia32.cc
|
|
|
|
|
DEFINE_bool(inline_new, true, "use fast inline allocation")
|
|
|
|
|
|
|
|
|
|
// checks.cc
|
|
|
|
|
DEFINE_bool(stack_trace_on_abort, true,
|
|
|
|
|
"print a stack trace if an assertion failure occurs")
|
|
|
|
|
|
|
|
|
|
// codegen-ia32.cc / codegen-arm.cc
|
2013-05-24 10:57:59 +00:00
|
|
|
DEFINE_bool(trace_codegen, false,
|
|
|
|
|
"print name of functions for which code is generated")
|
2008-09-12 10:19:33 +00:00
|
|
|
DEFINE_bool(trace, false, "trace function calls")
|
2010-10-29 06:15:34 +00:00
|
|
|
DEFINE_bool(mask_constants_with_cookie,
|
|
|
|
|
true,
|
|
|
|
|
"use random jit cookie to mask large constants")
|
2008-09-12 10:19:33 +00:00
|
|
|
|
|
|
|
|
// codegen.cc
|
|
|
|
|
DEFINE_bool(lazy, true, "use lazy compilation")
|
2010-12-07 11:31:57 +00:00
|
|
|
DEFINE_bool(trace_opt, false, "trace lazy optimization")
|
2010-12-09 13:12:23 +00:00
|
|
|
DEFINE_bool(trace_opt_stats, false, "trace lazy optimization statistics")
|
2010-12-07 11:31:57 +00:00
|
|
|
DEFINE_bool(opt, true, "use adaptive optimizations")
|
|
|
|
|
DEFINE_bool(always_opt, false, "always try to optimize functions")
|
|
|
|
|
DEFINE_bool(prepare_always_opt, false, "prepare for turning on always opt")
|
2013-02-05 16:28:36 +00:00
|
|
|
DEFINE_bool(trace_deopt, false, "trace optimize function deoptimization")
|
|
|
|
|
DEFINE_bool(trace_stub_failures, false,
|
|
|
|
|
"trace deoptimization of generated code stubs")
|
2008-09-12 10:19:33 +00:00
|
|
|
|
|
|
|
|
// compiler.cc
|
|
|
|
|
DEFINE_int(min_preparse_length, 1024,
|
Initial infrastructure for fast compilation of top-level code. The
fast code generator is optimized for compilation time and code size.
Currently it is only implemented on IA32. It is potentially triggered
for any code in the global scope (including code eval'd in the global
scope). It performs a syntactic check and chooses to compile in fast
mode if the AST contains only supported constructs and matches some
other constraints.
Initially supported constructs are
* ExpressionStatement,
* ReturnStatement,
* VariableProxy (variable references) to parameters and
stack-allocated locals,
* Assignment with lhs a parameter or stack-allocated local, and
* Literal
This allows compilation of literals at the top level and not much
else.
All intermediate values are allocated to temporaries and the stack is
used for all temporaries. The extra memory traffic is a known issue.
The code generated for 'true' is:
0 push ebp
1 mov ebp,esp
3 push esi
4 push edi
5 push 0xf5cca135 ;; object: 0xf5cca135 <undefined>
10 cmp esp,[0x8277efc]
16 jnc 27 (0xf5cbbb1b)
22 call 0xf5cac960 ;; code: STUB, StackCheck, minor: 0
27 push 0xf5cca161 ;; object: 0xf5cca161 <true>
32 mov eax,[esp]
35 mov [ebp+0xf4],eax
38 pop eax
39 mov eax,[ebp+0xf4]
42 mov esp,ebp ;; js return
44 pop ebp
45 ret 0x4
48 mov eax,0xf5cca135 ;; object: 0xf5cca135 <undefined>
53 mov esp,ebp ;; js return
55 pop ebp
56 ret 0x4
Review URL: http://codereview.chromium.org/273050
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3067 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-14 19:30:50 +00:00
|
|
|
"minimum length for automatic enable preparsing")
|
2010-02-03 20:39:34 +00:00
|
|
|
DEFINE_bool(always_full_compiler, false,
|
2010-01-27 15:23:48 +00:00
|
|
|
"try to use the dedicated run-once backend for all code")
|
2012-08-16 11:40:03 +00:00
|
|
|
DEFINE_int(max_opt_count, 10,
|
|
|
|
|
"maximum number of optimization attempts before giving up.")
|
2008-09-12 10:19:33 +00:00
|
|
|
|
2009-05-20 20:28:33 +00:00
|
|
|
// compilation-cache.cc
|
|
|
|
|
DEFINE_bool(compilation_cache, true, "enable compilation cache")
|
|
|
|
|
|
2011-04-26 09:44:55 +00:00
|
|
|
DEFINE_bool(cache_prototype_transitions, true, "cache prototype transitions")
|
|
|
|
|
|
2008-09-12 10:19:33 +00:00
|
|
|
// debug.cc
|
|
|
|
|
DEFINE_bool(trace_debug_json, false, "trace debugging JSON request/response")
|
2013-02-08 14:32:38 +00:00
|
|
|
DEFINE_bool(trace_js_array_abuse, false,
|
|
|
|
|
"trace out-of-bounds accesses to JS arrays")
|
|
|
|
|
DEFINE_bool(trace_external_array_abuse, false,
|
|
|
|
|
"trace out-of-bounds-accesses to external arrays")
|
|
|
|
|
DEFINE_bool(trace_array_abuse, false,
|
|
|
|
|
"trace out-of-bounds accesses to all arrays")
|
|
|
|
|
DEFINE_implication(trace_array_abuse, trace_js_array_abuse)
|
|
|
|
|
DEFINE_implication(trace_array_abuse, trace_external_array_abuse)
|
2009-11-25 10:11:34 +00:00
|
|
|
DEFINE_bool(debugger_auto_break, true,
|
2009-03-13 13:26:21 +00:00
|
|
|
"automatically set the debug break flag when debugger commands are "
|
2009-11-25 10:11:34 +00:00
|
|
|
"in the queue")
|
2010-03-05 22:08:58 +00:00
|
|
|
DEFINE_bool(enable_liveedit, true, "enable liveedit experimental feature")
|
2012-03-16 13:43:04 +00:00
|
|
|
DEFINE_bool(break_on_abort, true, "always cause a debug break before aborting")
|
2008-09-12 10:19:33 +00:00
|
|
|
|
2011-02-11 14:26:56 +00:00
|
|
|
// execution.cc
|
2012-04-05 12:32:35 +00:00
|
|
|
// Slightly less than 1MB on 64-bit, since Windows' default stack size for
|
|
|
|
|
// the main execution thread is 1MB for both 32 and 64-bit.
|
2012-04-05 14:01:39 +00:00
|
|
|
DEFINE_int(stack_size, kPointerSize * 123,
|
2012-01-30 12:25:29 +00:00
|
|
|
"default size of stack region v8 is allowed to use (in kBytes)")
|
2011-02-11 14:26:56 +00:00
|
|
|
|
2008-09-12 10:19:33 +00:00
|
|
|
// frames.cc
|
|
|
|
|
DEFINE_int(max_stack_trace_source_length, 300,
|
|
|
|
|
"maximum length of function source code printed in a stack trace.")
|
|
|
|
|
|
2010-09-15 10:14:25 +00:00
|
|
|
// full-codegen.cc
|
|
|
|
|
DEFINE_bool(always_inline_smi_code, false,
|
|
|
|
|
"always inline smi code in non-opt code")
|
|
|
|
|
|
2008-09-12 10:19:33 +00:00
|
|
|
// heap.cc
|
2010-09-30 07:22:53 +00:00
|
|
|
DEFINE_int(max_new_space_size, 0, "max size of the new generation (in kBytes)")
|
|
|
|
|
DEFINE_int(max_old_space_size, 0, "max size of the old generation (in Mbytes)")
|
2010-11-10 08:38:42 +00:00
|
|
|
DEFINE_int(max_executable_size, 0, "max size of executable memory (in Mbytes)")
|
2008-09-12 10:19:33 +00:00
|
|
|
DEFINE_bool(gc_global, false, "always perform global GCs")
|
|
|
|
|
DEFINE_int(gc_interval, -1, "garbage collect after <n> allocations")
|
|
|
|
|
DEFINE_bool(trace_gc, false,
|
|
|
|
|
"print one trace line following each garbage collection")
|
2010-05-18 16:50:17 +00:00
|
|
|
DEFINE_bool(trace_gc_nvp, false,
|
|
|
|
|
"print one detailed trace line in name=value format "
|
|
|
|
|
"after each garbage collection")
|
2012-08-07 08:19:11 +00:00
|
|
|
DEFINE_bool(trace_gc_ignore_scavenger, false,
|
|
|
|
|
"do not print trace line after scavenger collection")
|
2010-05-18 16:50:17 +00:00
|
|
|
DEFINE_bool(print_cumulative_gc_stat, false,
|
|
|
|
|
"print cumulative GC statistics in name=value format on exit")
|
2009-07-13 21:24:54 +00:00
|
|
|
DEFINE_bool(trace_gc_verbose, false,
|
|
|
|
|
"print more details following each garbage collection")
|
2011-09-19 18:36:47 +00:00
|
|
|
DEFINE_bool(trace_fragmentation, false,
|
|
|
|
|
"report fragmentation for old pointer and data pages")
|
2012-08-07 14:17:35 +00:00
|
|
|
DEFINE_bool(trace_external_memory, false,
|
|
|
|
|
"print amount of external allocated memory after each time "
|
|
|
|
|
"it is adjusted.")
|
2009-03-09 16:24:46 +00:00
|
|
|
DEFINE_bool(collect_maps, true,
|
2008-10-29 10:37:14 +00:00
|
|
|
"garbage collect maps from which no objects can be reached")
|
2013-03-20 15:20:19 +00:00
|
|
|
DEFINE_bool(weak_embedded_maps_in_optimized_code, false,
|
2013-01-28 10:25:38 +00:00
|
|
|
"make maps embedded in optimized code weak")
|
2011-09-29 13:51:47 +00:00
|
|
|
DEFINE_bool(flush_code, true,
|
2012-11-06 11:54:05 +00:00
|
|
|
"flush code that we expect not to use again (during full gc)")
|
2012-12-03 13:39:21 +00:00
|
|
|
DEFINE_bool(flush_code_incrementally, true,
|
2012-11-06 11:54:05 +00:00
|
|
|
"flush code that we expect not to use again (incrementally)")
|
2013-05-15 16:09:25 +00:00
|
|
|
DEFINE_bool(trace_code_flushing, false, "trace code flushing progress")
|
2012-12-04 08:58:59 +00:00
|
|
|
DEFINE_bool(age_code, true,
|
2012-11-08 12:18:11 +00:00
|
|
|
"track un-executed functions to age code and flush only "
|
|
|
|
|
"old code")
|
2011-09-19 18:36:47 +00:00
|
|
|
DEFINE_bool(incremental_marking, true, "use incremental marking")
|
|
|
|
|
DEFINE_bool(incremental_marking_steps, true, "do incremental marking steps")
|
|
|
|
|
DEFINE_bool(trace_incremental_marking, false,
|
|
|
|
|
"trace progress of the incremental marking")
|
2012-07-13 12:22:09 +00:00
|
|
|
DEFINE_bool(track_gc_object_stats, false,
|
|
|
|
|
"track object counts and memory usage")
|
2013-02-13 09:23:30 +00:00
|
|
|
DEFINE_bool(parallel_sweeping, true, "enable parallel sweeping")
|
2013-01-30 12:19:32 +00:00
|
|
|
DEFINE_bool(concurrent_sweeping, false, "enable concurrent sweeping")
|
2013-02-27 12:55:55 +00:00
|
|
|
DEFINE_int(sweeper_threads, 0,
|
2013-01-30 12:19:32 +00:00
|
|
|
"number of parallel and concurrent sweeping threads")
|
2013-01-31 14:23:36 +00:00
|
|
|
DEFINE_bool(parallel_marking, false, "enable parallel marking")
|
2013-02-27 12:55:55 +00:00
|
|
|
DEFINE_int(marking_threads, 0, "number of parallel marking threads")
|
2012-10-12 11:41:14 +00:00
|
|
|
#ifdef VERIFY_HEAP
|
|
|
|
|
DEFINE_bool(verify_heap, false, "verify heap pointers before and after GC")
|
|
|
|
|
#endif
|
2008-09-12 10:19:33 +00:00
|
|
|
|
2009-08-13 12:03:42 +00:00
|
|
|
// v8.cc
|
|
|
|
|
DEFINE_bool(use_idle_notification, true,
|
|
|
|
|
"Use idle notification to reduce memory footprint.")
|
2008-09-12 10:19:33 +00:00
|
|
|
// ic.cc
|
|
|
|
|
DEFINE_bool(use_ic, true, "use inline caching")
|
|
|
|
|
|
|
|
|
|
// macro-assembler-ia32.cc
|
|
|
|
|
DEFINE_bool(native_code_counters, false,
|
|
|
|
|
"generate extra code for manipulating stats counters")
|
|
|
|
|
|
|
|
|
|
// mark-compact.cc
|
2011-10-04 09:12:02 +00:00
|
|
|
DEFINE_bool(always_compact, false, "Perform compaction on every full GC")
|
2011-09-19 18:36:47 +00:00
|
|
|
DEFINE_bool(lazy_sweeping, true,
|
|
|
|
|
"Use lazy sweeping for old pointer and data spaces")
|
2011-09-26 11:46:16 +00:00
|
|
|
DEFINE_bool(never_compact, false,
|
2008-09-12 10:19:33 +00:00
|
|
|
"Never perform compaction on full GC - testing only")
|
2012-02-08 15:44:07 +00:00
|
|
|
DEFINE_bool(compact_code_space, true,
|
2012-02-07 10:03:08 +00:00
|
|
|
"Compact code space on full non-incremental collections")
|
2012-09-14 11:38:45 +00:00
|
|
|
DEFINE_bool(incremental_code_compaction, true,
|
2012-09-11 14:01:39 +00:00
|
|
|
"Compact code space on full incremental collections")
|
2011-05-18 13:17:29 +00:00
|
|
|
DEFINE_bool(cleanup_code_caches_at_gc, true,
|
|
|
|
|
"Flush inline caches prior to mark compact collection and "
|
|
|
|
|
"flush code caches in maps during mark compact cycle.")
|
2012-11-19 17:23:58 +00:00
|
|
|
DEFINE_bool(use_marking_progress_bar, true,
|
2012-11-15 17:57:40 +00:00
|
|
|
"Use a progress bar to scan large objects in increments when "
|
|
|
|
|
"incremental marking is active.")
|
2010-03-24 10:32:23 +00:00
|
|
|
DEFINE_int(random_seed, 0,
|
|
|
|
|
"Default seed for initializing random generator "
|
|
|
|
|
"(0, the default, means to use system random).")
|
2008-09-12 10:19:33 +00:00
|
|
|
|
2010-12-20 10:38:19 +00:00
|
|
|
// objects.cc
|
|
|
|
|
DEFINE_bool(use_verbose_printer, true, "allows verbose printing")
|
|
|
|
|
|
2008-09-12 10:19:33 +00:00
|
|
|
// parser.cc
|
|
|
|
|
DEFINE_bool(allow_natives_syntax, false, "allow natives syntax")
|
2012-07-18 11:22:46 +00:00
|
|
|
DEFINE_bool(trace_parse, false, "trace parsing and preparsing")
|
2008-09-12 10:19:33 +00:00
|
|
|
|
2010-02-04 20:36:58 +00:00
|
|
|
// simulator-arm.cc and simulator-mips.cc
|
2010-04-15 09:34:47 +00:00
|
|
|
DEFINE_bool(trace_sim, false, "Trace simulator execution")
|
2011-10-28 08:14:46 +00:00
|
|
|
DEFINE_bool(check_icache, false,
|
|
|
|
|
"Check icache flushes in ARM and MIPS simulator")
|
2008-09-12 10:19:33 +00:00
|
|
|
DEFINE_int(stop_sim_at, 0, "Simulator stop after x number of instructions")
|
2010-04-15 09:34:47 +00:00
|
|
|
DEFINE_int(sim_stack_alignment, 8,
|
|
|
|
|
"Stack alingment in bytes in simulator (4 or 8, 8 is default)")
|
2008-09-12 10:19:33 +00:00
|
|
|
|
2011-05-13 08:54:16 +00:00
|
|
|
// isolate.cc
|
2013-04-09 11:31:10 +00:00
|
|
|
DEFINE_bool(abort_on_uncaught_exception, false,
|
|
|
|
|
"abort program (dump core) when an uncaught exception is thrown")
|
2008-09-12 10:19:33 +00:00
|
|
|
DEFINE_bool(trace_exception, false,
|
|
|
|
|
"print stack trace when throwing exceptions")
|
|
|
|
|
DEFINE_bool(preallocate_message_memory, false,
|
|
|
|
|
"preallocate some memory to build stack traces.")
|
2012-01-10 13:24:18 +00:00
|
|
|
DEFINE_bool(randomize_hashes,
|
2012-01-04 15:12:15 +00:00
|
|
|
true,
|
2012-01-10 13:24:18 +00:00
|
|
|
"randomize hashes to avoid predictable hash collisions "
|
2012-01-04 15:12:15 +00:00
|
|
|
"(with snapshots this option cannot override the baked-in seed)")
|
2012-01-10 13:24:18 +00:00
|
|
|
DEFINE_int(hash_seed,
|
2012-01-04 15:12:15 +00:00
|
|
|
0,
|
2012-01-10 13:24:18 +00:00
|
|
|
"Fixed seed to use to hash property keys (0 means random)"
|
2012-01-04 15:12:15 +00:00
|
|
|
"(with snapshots this option cannot override the baked-in seed)")
|
2008-09-12 10:19:33 +00:00
|
|
|
|
|
|
|
|
// v8.cc
|
|
|
|
|
DEFINE_bool(preemption, false,
|
|
|
|
|
"activate a 100ms timer that switches between V8 threads")
|
|
|
|
|
|
2009-02-25 08:08:01 +00:00
|
|
|
// Regexp
|
|
|
|
|
DEFINE_bool(regexp_optimization, true, "generate optimized regexp code")
|
2008-11-25 14:26:45 +00:00
|
|
|
|
2008-09-12 10:19:33 +00:00
|
|
|
// Testing flags test/cctest/test-{flags,api,serialization}.cc
|
|
|
|
|
DEFINE_bool(testing_bool_flag, true, "testing_bool_flag")
|
|
|
|
|
DEFINE_int(testing_int_flag, 13, "testing_int_flag")
|
|
|
|
|
DEFINE_float(testing_float_flag, 2.5, "float-flag")
|
|
|
|
|
DEFINE_string(testing_string_flag, "Hello, world!", "string-flag")
|
|
|
|
|
DEFINE_int(testing_prng_seed, 42, "Seed used for threading test randomness")
|
|
|
|
|
#ifdef WIN32
|
|
|
|
|
DEFINE_string(testing_serialization_file, "C:\\Windows\\Temp\\serdes",
|
|
|
|
|
"file in which to testing_serialize heap")
|
|
|
|
|
#else
|
|
|
|
|
DEFINE_string(testing_serialization_file, "/tmp/serdes",
|
|
|
|
|
"file in which to serialize heap")
|
|
|
|
|
#endif
|
|
|
|
|
|
2012-06-19 18:38:03 +00:00
|
|
|
// mksnapshot.cc
|
|
|
|
|
DEFINE_string(extra_code, NULL, "A filename with extra code to be included in"
|
|
|
|
|
" the snapshot (mksnapshot only)")
|
|
|
|
|
|
2008-10-21 09:12:27 +00:00
|
|
|
//
|
|
|
|
|
// Dev shell flags
|
|
|
|
|
//
|
2008-09-12 10:19:33 +00:00
|
|
|
|
2008-11-06 10:43:15 +00:00
|
|
|
DEFINE_bool(help, false, "Print usage message, including flags, on console")
|
2008-10-21 09:12:27 +00:00
|
|
|
DEFINE_bool(dump_counters, false, "Dump counters on exit")
|
2011-09-29 08:55:36 +00:00
|
|
|
|
|
|
|
|
#ifdef ENABLE_DEBUGGER_SUPPORT
|
2010-06-08 12:04:49 +00:00
|
|
|
DEFINE_bool(debugger, false, "Enable JavaScript debugger")
|
2009-03-04 09:42:51 +00:00
|
|
|
DEFINE_bool(remote_debugger, false, "Connect JavaScript debugger to the "
|
|
|
|
|
"debugger agent in another process")
|
2009-03-03 12:23:45 +00:00
|
|
|
DEFINE_bool(debugger_agent, false, "Enable debugger agent")
|
|
|
|
|
DEFINE_int(debugger_port, 5858, "Port to use for remote debugging")
|
2011-09-29 08:55:36 +00:00
|
|
|
#endif // ENABLE_DEBUGGER_SUPPORT
|
|
|
|
|
|
2011-03-01 12:26:19 +00:00
|
|
|
DEFINE_string(map_counters, "", "Map counters to a file")
|
2012-03-12 13:56:56 +00:00
|
|
|
DEFINE_args(js_arguments, JSARGUMENTS_INIT,
|
2008-11-11 14:16:24 +00:00
|
|
|
"Pass all remaining arguments to the script. Alias for \"--\".")
|
2008-09-12 10:19:33 +00:00
|
|
|
|
2011-01-06 13:14:32 +00:00
|
|
|
#if defined(WEBOS__)
|
|
|
|
|
DEFINE_bool(debug_compile_events, false, "Enable debugger compile events")
|
|
|
|
|
DEFINE_bool(debug_script_collected_events, false,
|
|
|
|
|
"Enable debugger script collected events")
|
|
|
|
|
#else
|
|
|
|
|
DEFINE_bool(debug_compile_events, true, "Enable debugger compile events")
|
|
|
|
|
DEFINE_bool(debug_script_collected_events, true,
|
|
|
|
|
"Enable debugger script collected events")
|
|
|
|
|
#endif
|
|
|
|
|
|
2011-01-18 16:11:01 +00:00
|
|
|
|
|
|
|
|
//
|
|
|
|
|
// GDB JIT integration flags.
|
|
|
|
|
//
|
|
|
|
|
|
|
|
|
|
DEFINE_bool(gdbjit, false, "enable GDBJIT interface (disables compacting GC)")
|
|
|
|
|
DEFINE_bool(gdbjit_full, false, "enable GDBJIT interface for all code objects")
|
2011-02-15 21:11:31 +00:00
|
|
|
DEFINE_bool(gdbjit_dump, false, "dump elf objects with debug info to disk")
|
2011-06-30 11:52:00 +00:00
|
|
|
DEFINE_string(gdbjit_dump_filter, "",
|
|
|
|
|
"dump only objects containing this substring")
|
2011-01-18 16:11:01 +00:00
|
|
|
|
2011-10-11 15:52:15 +00:00
|
|
|
// mark-compact.cc
|
|
|
|
|
DEFINE_bool(force_marking_deque_overflows, false,
|
|
|
|
|
"force overflows of marking deque by reducing it's size "
|
|
|
|
|
"to 64 words")
|
|
|
|
|
|
|
|
|
|
DEFINE_bool(stress_compaction, false,
|
|
|
|
|
"stress the GC compactor to flush out bugs (implies "
|
|
|
|
|
"--force_marking_deque_overflows)")
|
|
|
|
|
|
2008-09-12 10:19:33 +00:00
|
|
|
//
|
|
|
|
|
// Debug only flags
|
|
|
|
|
//
|
|
|
|
|
#undef FLAG
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
|
#define FLAG FLAG_FULL
|
|
|
|
|
#else
|
|
|
|
|
#define FLAG FLAG_READONLY
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
// checks.cc
|
|
|
|
|
DEFINE_bool(enable_slow_asserts, false,
|
|
|
|
|
"enable asserts that are slow to execute")
|
|
|
|
|
|
|
|
|
|
// codegen-ia32.cc / codegen-arm.cc
|
|
|
|
|
DEFINE_bool(print_source, false, "pretty print source code")
|
|
|
|
|
DEFINE_bool(print_builtin_source, false,
|
|
|
|
|
"pretty print source code for builtins")
|
|
|
|
|
DEFINE_bool(print_ast, false, "print source AST")
|
|
|
|
|
DEFINE_bool(print_builtin_ast, false, "print source AST for builtins")
|
|
|
|
|
DEFINE_string(stop_at, "", "function name where to insert a breakpoint")
|
|
|
|
|
|
|
|
|
|
// compiler.cc
|
|
|
|
|
DEFINE_bool(print_builtin_scopes, false, "print scopes for builtins")
|
|
|
|
|
DEFINE_bool(print_scopes, false, "print scopes")
|
|
|
|
|
|
|
|
|
|
// contexts.cc
|
|
|
|
|
DEFINE_bool(trace_contexts, false, "trace contexts operations")
|
|
|
|
|
|
|
|
|
|
// heap.cc
|
|
|
|
|
DEFINE_bool(gc_greedy, false, "perform GC prior to some allocations")
|
|
|
|
|
DEFINE_bool(gc_verbose, false, "print stuff during garbage collection")
|
|
|
|
|
DEFINE_bool(heap_stats, false, "report heap statistics before and after GC")
|
|
|
|
|
DEFINE_bool(code_stats, false, "report code statistics after GC")
|
2012-08-17 09:03:08 +00:00
|
|
|
DEFINE_bool(verify_native_context_separation, false,
|
|
|
|
|
"verify that code holds on to at most one native context after GC")
|
2008-09-12 10:19:33 +00:00
|
|
|
DEFINE_bool(print_handles, false, "report handles after GC")
|
|
|
|
|
DEFINE_bool(print_global_handles, false, "report global handles after GC")
|
|
|
|
|
|
|
|
|
|
// ic.cc
|
|
|
|
|
DEFINE_bool(trace_ic, false, "trace inline cache state transitions")
|
|
|
|
|
|
2012-03-08 13:03:07 +00:00
|
|
|
// interface.cc
|
|
|
|
|
DEFINE_bool(print_interfaces, false, "print interfaces")
|
|
|
|
|
DEFINE_bool(print_interface_details, false, "print interface inference details")
|
|
|
|
|
DEFINE_int(print_interface_depth, 5, "depth for printing interfaces")
|
|
|
|
|
|
2008-09-12 10:19:33 +00:00
|
|
|
// objects.cc
|
|
|
|
|
DEFINE_bool(trace_normalization,
|
|
|
|
|
false,
|
|
|
|
|
"prints when objects are turned into dictionaries.")
|
|
|
|
|
|
|
|
|
|
// runtime.cc
|
|
|
|
|
DEFINE_bool(trace_lazy, false, "trace lazy compilation")
|
|
|
|
|
|
|
|
|
|
// spaces.cc
|
|
|
|
|
DEFINE_bool(collect_heap_spill_statistics, false,
|
|
|
|
|
"report heap spill statistics along with heap_stats "
|
|
|
|
|
"(requires heap_stats)")
|
|
|
|
|
|
2011-03-18 20:35:07 +00:00
|
|
|
DEFINE_bool(trace_isolates, false, "trace isolate state changes")
|
|
|
|
|
|
2009-02-25 08:08:01 +00:00
|
|
|
// Regexp
|
2010-01-07 19:01:23 +00:00
|
|
|
DEFINE_bool(regexp_possessive_quantifier,
|
|
|
|
|
false,
|
|
|
|
|
"enable possessive quantifier syntax for testing")
|
2009-02-25 08:08:01 +00:00
|
|
|
DEFINE_bool(trace_regexp_bytecodes, false, "trace regexp bytecode execution")
|
|
|
|
|
DEFINE_bool(trace_regexp_assembler,
|
|
|
|
|
false,
|
|
|
|
|
"trace regexp macro assembler calls.")
|
2008-11-27 13:54:31 +00:00
|
|
|
|
2008-09-12 10:19:33 +00:00
|
|
|
//
|
2011-07-13 09:09:04 +00:00
|
|
|
// Logging and profiling flags
|
2008-09-12 10:19:33 +00:00
|
|
|
//
|
|
|
|
|
#undef FLAG
|
|
|
|
|
#define FLAG FLAG_FULL
|
|
|
|
|
|
|
|
|
|
// log.cc
|
|
|
|
|
DEFINE_bool(log, false,
|
|
|
|
|
"Minimal logging (no API, code, GC, suspect, or handles samples).")
|
|
|
|
|
DEFINE_bool(log_all, false, "Log all events to the log file.")
|
2009-02-17 12:49:35 +00:00
|
|
|
DEFINE_bool(log_runtime, false, "Activate runtime system %Log call.")
|
2008-09-12 10:19:33 +00:00
|
|
|
DEFINE_bool(log_api, false, "Log API events to the log file.")
|
|
|
|
|
DEFINE_bool(log_code, false,
|
|
|
|
|
"Log code events to the log file without profiling.")
|
|
|
|
|
DEFINE_bool(log_gc, false,
|
|
|
|
|
"Log heap samples on garbage collection for the hp2ps tool.")
|
|
|
|
|
DEFINE_bool(log_handles, false, "Log global handle events.")
|
2010-01-18 16:04:25 +00:00
|
|
|
DEFINE_bool(log_snapshot_positions, false,
|
|
|
|
|
"log positions of (de)serialized objects in the snapshot.")
|
2008-09-12 10:19:33 +00:00
|
|
|
DEFINE_bool(log_suspect, false, "Log suspect operations.")
|
|
|
|
|
DEFINE_bool(prof, false,
|
|
|
|
|
"Log statistical profiling information (implies --log-code).")
|
2009-01-29 19:47:00 +00:00
|
|
|
DEFINE_bool(prof_auto, true,
|
|
|
|
|
"Used with --prof, starts profiling automatically")
|
2009-05-25 08:25:36 +00:00
|
|
|
DEFINE_bool(prof_lazy, false,
|
|
|
|
|
"Used with --prof, only does sampling and logging"
|
|
|
|
|
" when profiler is active (implies --noprof_auto).")
|
2010-04-12 07:23:43 +00:00
|
|
|
DEFINE_bool(prof_browser_mode, true,
|
2010-04-06 14:54:20 +00:00
|
|
|
"Used with --prof, turns on browser-compatible mode for profiling.")
|
2008-09-12 10:19:33 +00:00
|
|
|
DEFINE_bool(log_regexp, false, "Log regular expression execution.")
|
|
|
|
|
DEFINE_string(logfile, "v8.log", "Specify the name of the log file.")
|
2010-10-19 16:45:11 +00:00
|
|
|
DEFINE_bool(ll_prof, false, "Enable low-level linux profiler.")
|
2012-09-06 15:01:20 +00:00
|
|
|
DEFINE_string(gc_fake_mmap, "/tmp/__v8_gc__",
|
|
|
|
|
"Specify the name of the file for fake gc mmap used in ll_prof")
|
2012-12-05 16:22:14 +00:00
|
|
|
DEFINE_bool(log_internal_timer_events, false, "Time internal events.")
|
|
|
|
|
DEFINE_bool(log_timer_events, false,
|
|
|
|
|
"Time events including external callbacks.")
|
|
|
|
|
DEFINE_implication(log_timer_events, log_internal_timer_events)
|
2013-04-24 14:44:08 +00:00
|
|
|
DEFINE_implication(log_internal_timer_events, prof)
|
2012-06-19 18:38:03 +00:00
|
|
|
|
2008-09-12 10:19:33 +00:00
|
|
|
//
|
|
|
|
|
// Disassembler only flags
|
|
|
|
|
//
|
|
|
|
|
#undef FLAG
|
|
|
|
|
#ifdef ENABLE_DISASSEMBLER
|
|
|
|
|
#define FLAG FLAG_FULL
|
|
|
|
|
#else
|
|
|
|
|
#define FLAG FLAG_READONLY
|
|
|
|
|
#endif
|
|
|
|
|
|
2011-10-20 09:38:24 +00:00
|
|
|
// elements.cc
|
|
|
|
|
DEFINE_bool(trace_elements_transitions, false, "trace elements transitions")
|
|
|
|
|
|
2009-03-04 06:14:34 +00:00
|
|
|
// code-stubs.cc
|
|
|
|
|
DEFINE_bool(print_code_stubs, false, "print code stubs")
|
2012-02-29 10:45:59 +00:00
|
|
|
DEFINE_bool(test_secondary_stub_cache,
|
|
|
|
|
false,
|
|
|
|
|
"test secondary stub cache by disabling the primary one")
|
|
|
|
|
|
|
|
|
|
DEFINE_bool(test_primary_stub_cache,
|
|
|
|
|
false,
|
|
|
|
|
"test primary stub cache by disabling the secondary one")
|
2009-03-04 06:14:34 +00:00
|
|
|
|
2008-09-12 10:19:33 +00:00
|
|
|
// codegen-ia32.cc / codegen-arm.cc
|
|
|
|
|
DEFINE_bool(print_code, false, "print generated code")
|
2010-12-07 11:31:57 +00:00
|
|
|
DEFINE_bool(print_opt_code, false, "print optimized code")
|
2010-12-17 14:16:00 +00:00
|
|
|
DEFINE_bool(print_unopt_code, false, "print unoptimized code before "
|
|
|
|
|
"printing optimized code based on it")
|
2010-12-07 11:31:57 +00:00
|
|
|
DEFINE_bool(print_code_verbose, false, "print more information for code")
|
2008-12-04 08:26:08 +00:00
|
|
|
DEFINE_bool(print_builtin_code, false, "print generated code for builtins")
|
2008-09-12 10:19:33 +00:00
|
|
|
|
2011-12-15 17:00:27 +00:00
|
|
|
#ifdef ENABLE_DISASSEMBLER
|
|
|
|
|
DEFINE_bool(print_all_code, false, "enable all flags related to printing code")
|
|
|
|
|
DEFINE_implication(print_all_code, print_code)
|
|
|
|
|
DEFINE_implication(print_all_code, print_opt_code)
|
|
|
|
|
DEFINE_implication(print_all_code, print_unopt_code)
|
|
|
|
|
DEFINE_implication(print_all_code, print_code_verbose)
|
|
|
|
|
DEFINE_implication(print_all_code, print_builtin_code)
|
|
|
|
|
DEFINE_implication(print_all_code, print_code_stubs)
|
2011-12-16 08:38:52 +00:00
|
|
|
DEFINE_implication(print_all_code, code_comments)
|
2011-12-21 16:19:55 +00:00
|
|
|
#ifdef DEBUG
|
|
|
|
|
DEFINE_implication(print_all_code, trace_codegen)
|
|
|
|
|
#endif
|
2011-12-15 17:00:27 +00:00
|
|
|
#endif
|
|
|
|
|
|
2008-09-12 10:19:33 +00:00
|
|
|
// Cleanup...
|
|
|
|
|
#undef FLAG_FULL
|
|
|
|
|
#undef FLAG_READONLY
|
|
|
|
|
#undef FLAG
|
|
|
|
|
|
|
|
|
|
#undef DEFINE_bool
|
|
|
|
|
#undef DEFINE_int
|
|
|
|
|
#undef DEFINE_string
|
2011-12-15 17:00:27 +00:00
|
|
|
#undef DEFINE_implication
|
2008-09-12 10:19:33 +00:00
|
|
|
|
|
|
|
|
#undef FLAG_MODE_DECLARE
|
|
|
|
|
#undef FLAG_MODE_DEFINE
|
|
|
|
|
#undef FLAG_MODE_DEFINE_DEFAULTS
|
|
|
|
|
#undef FLAG_MODE_META
|
2011-12-15 17:00:27 +00:00
|
|
|
#undef FLAG_MODE_DEFINE_IMPLICATIONS
|
