2012-01-30 12:25:29 +00:00
|
|
|
// Copyright 2012 the V8 project authors. All rights reserved.
|
2014-04-29 06:42:26 +00:00
|
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
|
|
// found in the LICENSE file.
|
2008-09-12 10:19:33 +00:00
|
|
|
|
|
|
|
// 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:
|
|
|
|
|
2014-09-19 09:15:47 +00:00
|
|
|
#define DEFINE_IMPLICATION(whenflag, thenflag) \
|
|
|
|
DEFINE_VALUE_IMPLICATION(whenflag, thenflag, true)
|
|
|
|
|
|
|
|
#define DEFINE_NEG_IMPLICATION(whenflag, thenflag) \
|
|
|
|
DEFINE_VALUE_IMPLICATION(whenflag, thenflag, false)
|
|
|
|
|
2014-12-05 15:35:32 +00:00
|
|
|
#define DEFINE_NEG_NEG_IMPLICATION(whenflag, thenflag) \
|
|
|
|
DEFINE_NEG_VALUE_IMPLICATION(whenflag, thenflag, false)
|
|
|
|
|
2008-09-12 10:19:33 +00:00
|
|
|
// 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)
|
2016-09-20 12:06:34 +00:00
|
|
|
#define FLAG_FULL(ftype, ctype, nam, def, cmt) \
|
|
|
|
V8_EXPORT_PRIVATE extern ctype FLAG_##nam;
|
2008-09-12 10:19:33 +00:00
|
|
|
#define FLAG_READONLY(ftype, ctype, nam, def, cmt) \
|
|
|
|
static ctype const FLAG_##nam = def;
|
|
|
|
|
|
|
|
// 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)
|
2016-09-20 12:06:34 +00:00
|
|
|
#ifdef USING_V8_SHARED
|
|
|
|
#define FLAG_FULL(ftype, ctype, nam, def, cmt) \
|
|
|
|
V8_EXPORT_PRIVATE extern ctype FLAG_##nam;
|
|
|
|
#else
|
|
|
|
#define FLAG_FULL(ftype, ctype, nam, def, cmt) \
|
|
|
|
V8_EXPORT_PRIVATE ctype FLAG_##nam = def;
|
|
|
|
#endif
|
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;
|
|
|
|
|
|
|
|
// 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)
|
2014-07-02 14:00:16 +00:00
|
|
|
#define FLAG_FULL(ftype, ctype, nam, def, cmt) \
|
|
|
|
{ Flag::TYPE_##ftype, #nam, &FLAG_##nam, &FLAGDEFAULT_##nam, cmt, false } \
|
|
|
|
,
|
|
|
|
#define FLAG_ALIAS(ftype, ctype, alias, nam) \
|
|
|
|
{ \
|
|
|
|
Flag::TYPE_##ftype, #alias, &FLAG_##nam, &FLAGDEFAULT_##nam, \
|
|
|
|
"alias for --" #nam, false \
|
|
|
|
} \
|
|
|
|
,
|
2011-12-15 17:00:27 +00:00
|
|
|
|
|
|
|
// We produce the code to set flags when it is implied by another flag.
|
|
|
|
#elif defined(FLAG_MODE_DEFINE_IMPLICATIONS)
|
2014-09-19 09:15:47 +00:00
|
|
|
#define DEFINE_VALUE_IMPLICATION(whenflag, thenflag, value) \
|
|
|
|
if (FLAG_##whenflag) FLAG_##thenflag = value;
|
2013-12-18 17:31:12 +00:00
|
|
|
|
2014-12-05 15:35:32 +00:00
|
|
|
#define DEFINE_NEG_VALUE_IMPLICATION(whenflag, thenflag, value) \
|
|
|
|
if (!FLAG_##whenflag) FLAG_##thenflag = value;
|
|
|
|
|
2008-09-12 10:19:33 +00:00
|
|
|
#else
|
|
|
|
#error No mode supplied when including flags.defs
|
|
|
|
#endif
|
|
|
|
|
2013-08-22 16:14:37 +00:00
|
|
|
// Dummy defines for modes where it is not relevant.
|
|
|
|
#ifndef FLAG_FULL
|
|
|
|
#define FLAG_FULL(ftype, ctype, nam, def, cmt)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef FLAG_READONLY
|
|
|
|
#define FLAG_READONLY(ftype, ctype, nam, def, cmt)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef FLAG_ALIAS
|
|
|
|
#define FLAG_ALIAS(ftype, ctype, alias, nam)
|
|
|
|
#endif
|
|
|
|
|
2014-09-19 09:15:47 +00:00
|
|
|
#ifndef DEFINE_VALUE_IMPLICATION
|
|
|
|
#define DEFINE_VALUE_IMPLICATION(whenflag, thenflag, value)
|
2013-12-18 17:31:12 +00:00
|
|
|
#endif
|
|
|
|
|
2014-12-05 15:35:32 +00:00
|
|
|
#ifndef DEFINE_NEG_VALUE_IMPLICATION
|
|
|
|
#define DEFINE_NEG_VALUE_IMPLICATION(whenflag, thenflag, value)
|
|
|
|
#endif
|
|
|
|
|
2013-09-17 13:48:17 +00:00
|
|
|
#define COMMA ,
|
2013-08-22 16:14:37 +00:00
|
|
|
|
2008-11-11 14:16:24 +00:00
|
|
|
#ifdef FLAG_MODE_DECLARE
|
|
|
|
// Structure used to hold a collection of arguments to the JavaScript code.
|
|
|
|
struct JSArguments {
|
2014-07-02 14:00:16 +00:00
|
|
|
public:
|
|
|
|
inline const char*& operator[](int idx) const { return argv[idx]; }
|
2012-03-12 13:56:56 +00:00
|
|
|
static JSArguments Create(int argc, const char** argv) {
|
|
|
|
JSArguments args;
|
2013-09-17 13:48:17 +00:00
|
|
|
args.argc = argc;
|
|
|
|
args.argv = argv;
|
2012-03-12 13:56:56 +00:00
|
|
|
return args;
|
|
|
|
}
|
2013-09-17 13:48:17 +00:00
|
|
|
int argc;
|
|
|
|
const char** argv;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct MaybeBoolFlag {
|
|
|
|
static MaybeBoolFlag Create(bool has_value, bool value) {
|
|
|
|
MaybeBoolFlag flag;
|
|
|
|
flag.has_value = has_value;
|
|
|
|
flag.value = value;
|
|
|
|
return flag;
|
2012-03-12 13:56:56 +00:00
|
|
|
}
|
2013-09-17 13:48:17 +00:00
|
|
|
bool has_value;
|
|
|
|
bool value;
|
2008-11-11 14:16:24 +00:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
2015-01-15 12:17:23 +00:00
|
|
|
#ifdef DEBUG
|
|
|
|
#define DEBUG_BOOL true
|
|
|
|
#else
|
|
|
|
#define DEBUG_BOOL false
|
|
|
|
#endif
|
2016-08-30 10:01:50 +00:00
|
|
|
|
|
|
|
// Supported ARM configurations are:
|
|
|
|
// "armv6": ARMv6 + VFPv2
|
|
|
|
// "armv7": ARMv7 + VFPv3-D32 + NEON
|
|
|
|
// "armv7+sudiv": ARMv7 + VFPv4-D32 + NEON + SUDIV
|
|
|
|
// "armv8": ARMv8 (including all of the above)
|
|
|
|
#if !defined(ARM_TEST_NO_FEATURE_PROBE) || \
|
|
|
|
(defined(CAN_USE_ARMV8_INSTRUCTIONS) && \
|
|
|
|
defined(CAN_USE_ARMV7_INSTRUCTIONS) && defined(CAN_USE_SUDIV) && \
|
|
|
|
defined(CAN_USE_NEON) && defined(CAN_USE_VFP3_INSTRUCTIONS))
|
|
|
|
#define ARM_ARCH_DEFAULT "armv8"
|
|
|
|
#elif defined(CAN_USE_ARMV7_INSTRUCTIONS) && defined(CAN_USE_SUDIV) && \
|
|
|
|
defined(CAN_USE_NEON) && defined(CAN_USE_VFP3_INSTRUCTIONS)
|
|
|
|
#define ARM_ARCH_DEFAULT "armv7+sudiv"
|
|
|
|
#elif defined(CAN_USE_ARMV7_INSTRUCTIONS) && defined(CAN_USE_NEON) && \
|
|
|
|
defined(CAN_USE_VFP3_INSTRUCTIONS)
|
|
|
|
#define ARM_ARCH_DEFAULT "armv7"
|
2014-05-12 09:25:32 +00:00
|
|
|
#else
|
2016-08-30 10:01:50 +00:00
|
|
|
#define ARM_ARCH_DEFAULT "armv6"
|
2014-05-12 09:25:32 +00:00
|
|
|
#endif
|
2016-08-30 10:01:50 +00:00
|
|
|
|
2016-01-28 18:17:30 +00:00
|
|
|
#ifdef V8_OS_WIN
|
|
|
|
# define ENABLE_LOG_COLOUR false
|
|
|
|
#else
|
|
|
|
# define ENABLE_LOG_COLOUR true
|
|
|
|
#endif
|
2013-04-16 14:39:48 +00:00
|
|
|
|
2014-07-02 14:00:16 +00:00
|
|
|
#define DEFINE_BOOL(nam, def, cmt) FLAG(BOOL, bool, nam, def, cmt)
|
2014-10-20 13:33:34 +00:00
|
|
|
#define DEFINE_BOOL_READONLY(nam, def, cmt) \
|
|
|
|
FLAG_READONLY(BOOL, bool, nam, def, cmt)
|
2014-07-02 14:00:16 +00:00
|
|
|
#define DEFINE_MAYBE_BOOL(nam, cmt) \
|
|
|
|
FLAG(MAYBE_BOOL, MaybeBoolFlag, nam, {false COMMA false}, cmt)
|
|
|
|
#define DEFINE_INT(nam, def, cmt) FLAG(INT, int, nam, def, cmt)
|
|
|
|
#define DEFINE_FLOAT(nam, def, cmt) FLAG(FLOAT, double, nam, def, cmt)
|
|
|
|
#define DEFINE_STRING(nam, def, cmt) FLAG(STRING, const char*, nam, def, cmt)
|
|
|
|
#define DEFINE_ARGS(nam, cmt) FLAG(ARGS, JSArguments, nam, {0 COMMA NULL}, cmt)
|
|
|
|
|
|
|
|
#define DEFINE_ALIAS_BOOL(alias, nam) FLAG_ALIAS(BOOL, bool, alias, nam)
|
|
|
|
#define DEFINE_ALIAS_INT(alias, nam) FLAG_ALIAS(INT, int, alias, nam)
|
|
|
|
#define DEFINE_ALIAS_FLOAT(alias, nam) FLAG_ALIAS(FLOAT, double, alias, nam)
|
|
|
|
#define DEFINE_ALIAS_STRING(alias, nam) \
|
2013-08-22 16:14:37 +00:00
|
|
|
FLAG_ALIAS(STRING, const char*, alias, nam)
|
2014-07-02 14:00:16 +00:00
|
|
|
#define DEFINE_ALIAS_ARGS(alias, nam) FLAG_ALIAS(ARGS, JSArguments, alias, nam)
|
2008-09-12 10:19:33 +00:00
|
|
|
|
|
|
|
//
|
|
|
|
// Flags in all modes.
|
|
|
|
//
|
|
|
|
#define FLAG FLAG_FULL
|
|
|
|
|
2015-08-20 00:01:07 +00:00
|
|
|
DEFINE_BOOL(experimental_extras, false,
|
|
|
|
"enable code compiled in via v8_experimental_extra_library_files")
|
|
|
|
|
2012-02-20 13:48:24 +00:00
|
|
|
// Flags for language modes and experimental language features.
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(use_strict, false, "enforce strict mode")
|
2012-02-20 13:48:24 +00:00
|
|
|
|
2015-11-03 14:16:19 +00:00
|
|
|
DEFINE_BOOL(es_staging, false,
|
|
|
|
"enable test-worthy harmony features (for internal use only)")
|
2014-11-04 16:05:27 +00:00
|
|
|
DEFINE_BOOL(harmony, false, "enable all completed harmony features")
|
2015-10-26 07:39:06 +00:00
|
|
|
DEFINE_BOOL(harmony_shipping, true, "enable all shipped harmony features")
|
2014-11-26 12:28:36 +00:00
|
|
|
DEFINE_IMPLICATION(es_staging, harmony)
|
2014-07-02 14:00:16 +00:00
|
|
|
|
2016-05-12 00:32:42 +00:00
|
|
|
|
2015-11-03 14:16:19 +00:00
|
|
|
// Activate on ClusterFuzz.
|
2015-12-16 10:52:49 +00:00
|
|
|
DEFINE_IMPLICATION(es_staging, harmony_regexp_lookbehind)
|
2015-12-23 11:48:40 +00:00
|
|
|
DEFINE_IMPLICATION(es_staging, move_object_start)
|
2015-07-07 21:57:09 +00:00
|
|
|
|
2014-11-04 16:05:27 +00:00
|
|
|
// Features that are still work in progress (behind individual flags).
|
2016-09-07 17:16:51 +00:00
|
|
|
#define HARMONY_INPROGRESS(V) \
|
2016-06-17 10:37:19 +00:00
|
|
|
V(harmony_array_prototype_values, "harmony Array.prototype.values") \
|
2016-05-16 23:17:13 +00:00
|
|
|
V(harmony_function_sent, "harmony function.sent") \
|
|
|
|
V(harmony_sharedarraybuffer, "harmony sharedarraybuffer") \
|
|
|
|
V(harmony_simd, "harmony simd") \
|
|
|
|
V(harmony_do_expressions, "harmony do-expressions") \
|
2016-06-15 06:48:31 +00:00
|
|
|
V(harmony_regexp_named_captures, "harmony regexp named captures") \
|
2016-05-16 23:17:13 +00:00
|
|
|
V(harmony_regexp_property, "harmony unicode regexp property classes") \
|
2016-09-16 00:42:30 +00:00
|
|
|
V(harmony_class_fields, "harmony public fields in class literals")
|
2014-10-20 13:33:34 +00:00
|
|
|
|
2014-11-04 16:05:27 +00:00
|
|
|
// Features that are complete (but still behind --harmony/es-staging flag).
|
2016-11-04 18:48:02 +00:00
|
|
|
#define HARMONY_STAGED_BASE(V) \
|
|
|
|
V(harmony_regexp_lookbehind, "harmony regexp lookbehind") \
|
|
|
|
V(harmony_restrictive_generators, \
|
|
|
|
"harmony restrictions on generator declarations") \
|
|
|
|
V(harmony_tailcalls, "harmony tail calls") \
|
2016-11-11 23:42:37 +00:00
|
|
|
V(harmony_trailing_commas, \
|
|
|
|
"harmony trailing commas in function parameter lists") \
|
2016-10-07 08:41:24 +00:00
|
|
|
V(harmony_string_padding, "harmony String-padding methods")
|
2016-05-23 18:39:25 +00:00
|
|
|
|
|
|
|
#ifdef V8_I18N_SUPPORT
|
2016-09-07 17:16:51 +00:00
|
|
|
#define HARMONY_STAGED(V) \
|
|
|
|
HARMONY_STAGED_BASE(V) \
|
|
|
|
V(datetime_format_to_parts, "Intl.DateTimeFormat.formatToParts") \
|
2016-05-19 18:52:38 +00:00
|
|
|
V(icu_case_mapping, "case mapping with ICU rather than Unibrow")
|
|
|
|
#else
|
2016-05-23 18:39:25 +00:00
|
|
|
#define HARMONY_STAGED(V) HARMONY_STAGED_BASE(V)
|
2016-05-19 18:52:38 +00:00
|
|
|
#endif
|
2015-06-04 17:33:20 +00:00
|
|
|
|
2014-11-04 16:05:27 +00:00
|
|
|
// Features that are shipping (turned on by default, but internal flag remains).
|
2016-11-04 18:50:22 +00:00
|
|
|
#define HARMONY_SHIPPING(V) V(harmony_async_await, "harmony async-await")
|
2014-11-04 16:05:27 +00:00
|
|
|
|
|
|
|
// Once a shipping feature has proved stable in the wild, it will be dropped
|
|
|
|
// from HARMONY_SHIPPING, all occurrences of the FLAG_ variable are removed,
|
|
|
|
// and associated tests are moved from the harmony directory to the appropriate
|
|
|
|
// esN directory.
|
2014-10-20 13:33:34 +00:00
|
|
|
|
|
|
|
|
2014-11-04 16:05:27 +00:00
|
|
|
#define FLAG_INPROGRESS_FEATURES(id, description) \
|
|
|
|
DEFINE_BOOL(id, false, "enable " #description " (in progress)")
|
|
|
|
HARMONY_INPROGRESS(FLAG_INPROGRESS_FEATURES)
|
|
|
|
#undef FLAG_INPROGRESS_FEATURES
|
2014-10-20 13:33:34 +00:00
|
|
|
|
2014-11-04 16:05:27 +00:00
|
|
|
#define FLAG_STAGED_FEATURES(id, description) \
|
|
|
|
DEFINE_BOOL(id, false, "enable " #description) \
|
2015-11-03 14:16:19 +00:00
|
|
|
DEFINE_IMPLICATION(harmony, id)
|
2014-11-04 16:05:27 +00:00
|
|
|
HARMONY_STAGED(FLAG_STAGED_FEATURES)
|
2014-10-20 13:33:34 +00:00
|
|
|
#undef FLAG_STAGED_FEATURES
|
|
|
|
|
2014-12-05 15:35:32 +00:00
|
|
|
#define FLAG_SHIPPING_FEATURES(id, description) \
|
|
|
|
DEFINE_BOOL(id, true, "enable " #description) \
|
|
|
|
DEFINE_NEG_NEG_IMPLICATION(harmony_shipping, id)
|
2014-11-04 16:05:27 +00:00
|
|
|
HARMONY_SHIPPING(FLAG_SHIPPING_FEATURES)
|
2014-10-20 13:33:34 +00:00
|
|
|
#undef FLAG_SHIPPING_FEATURES
|
|
|
|
|
2016-11-12 21:50:41 +00:00
|
|
|
DEFINE_BOOL(future, false,
|
|
|
|
"Implies all staged features that we want to ship in the "
|
|
|
|
"not-too-far future")
|
|
|
|
DEFINE_IMPLICATION(future, ignition_staging)
|
|
|
|
|
2011-06-09 10:03:35 +00:00
|
|
|
// Flags for experimental implementation features.
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(allocation_site_pretenuring, true,
|
2013-10-11 09:25:14 +00:00
|
|
|
"pretenure with allocation sites")
|
2016-04-20 09:29:33 +00:00
|
|
|
DEFINE_BOOL(page_promotion, true, "promote pages based on utilization")
|
|
|
|
DEFINE_INT(page_promotion_threshold, 70,
|
|
|
|
"min percentage of live bytes on a page to enable fast evacuation")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(trace_pretenuring, false,
|
2013-11-28 10:49:02 +00:00
|
|
|
"trace pretenuring decisions of HAllocate instructions")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(trace_pretenuring_statistics, false,
|
2014-02-06 10:30:13 +00:00
|
|
|
"trace allocation site pretenuring statistics")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(track_fields, true, "track fields with only smi values")
|
|
|
|
DEFINE_BOOL(track_double_fields, true, "track fields with double values")
|
|
|
|
DEFINE_BOOL(track_heap_object_fields, true, "track fields with heap values")
|
|
|
|
DEFINE_BOOL(track_computed_fields, true, "track computed boilerplate fields")
|
|
|
|
DEFINE_IMPLICATION(track_double_fields, track_fields)
|
|
|
|
DEFINE_IMPLICATION(track_heap_object_fields, track_fields)
|
|
|
|
DEFINE_IMPLICATION(track_computed_fields, track_fields)
|
|
|
|
DEFINE_BOOL(track_field_types, true, "track field types")
|
|
|
|
DEFINE_IMPLICATION(track_field_types, track_fields)
|
|
|
|
DEFINE_IMPLICATION(track_field_types, track_heap_object_fields)
|
|
|
|
DEFINE_BOOL(smi_binop, true, "support smi representation in binary operations")
|
2016-11-11 16:20:15 +00:00
|
|
|
DEFINE_BOOL(mark_shared_functions_for_tier_up, true,
|
2016-10-27 10:07:56 +00:00
|
|
|
"mark shared functions for tier up")
|
2011-10-11 11:35:04 +00:00
|
|
|
|
2013-09-26 09:40:13 +00:00
|
|
|
// Flags for optimization types.
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(optimize_for_size, false,
|
2013-09-26 09:40:13 +00:00
|
|
|
"Enables optimizations which favor memory size over execution "
|
2015-07-23 14:21:26 +00:00
|
|
|
"speed")
|
2013-09-26 09:40:13 +00:00
|
|
|
|
2014-09-19 09:15:47 +00:00
|
|
|
DEFINE_VALUE_IMPLICATION(optimize_for_size, max_semi_space_size, 1)
|
|
|
|
|
2012-01-30 12:25:29 +00:00
|
|
|
// Flags for data representation optimizations
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(unbox_double_arrays, true, "automatically unbox arrays of doubles")
|
|
|
|
DEFINE_BOOL(string_slices, true, "use string slices")
|
2012-01-30 12:25:29 +00:00
|
|
|
|
2015-07-23 14:21:26 +00:00
|
|
|
// Flags for Ignition.
|
|
|
|
DEFINE_BOOL(ignition, false, "use ignition interpreter")
|
2016-07-26 09:48:58 +00:00
|
|
|
DEFINE_BOOL(ignition_staging, false, "use ignition with all staged features")
|
|
|
|
DEFINE_IMPLICATION(ignition_staging, ignition)
|
2016-01-04 17:32:31 +00:00
|
|
|
DEFINE_STRING(ignition_filter, "*", "filter for ignition interpreter")
|
2016-06-21 15:26:50 +00:00
|
|
|
DEFINE_BOOL(ignition_deadcode, true,
|
|
|
|
"use ignition dead code elimination optimizer")
|
2016-11-11 10:41:45 +00:00
|
|
|
DEFINE_BOOL(ignition_osr, true, "enable support for OSR from ignition code")
|
2016-05-12 19:18:07 +00:00
|
|
|
DEFINE_BOOL(ignition_peephole, true, "use ignition peephole optimizer")
|
2016-05-27 15:57:35 +00:00
|
|
|
DEFINE_BOOL(ignition_reo, true, "use ignition register equivalence optimizer")
|
2016-06-09 13:32:33 +00:00
|
|
|
DEFINE_BOOL(ignition_filter_expression_positions, true,
|
|
|
|
"filter expression positions before the bytecode pipeline")
|
2015-08-18 13:46:43 +00:00
|
|
|
DEFINE_BOOL(print_bytecode, false,
|
|
|
|
"print bytecode generated by ignition interpreter")
|
2016-01-28 18:17:30 +00:00
|
|
|
DEFINE_BOOL(trace_ignition, false,
|
|
|
|
"trace the bytecodes executed by the ignition interpreter")
|
2015-07-23 14:21:26 +00:00
|
|
|
DEFINE_BOOL(trace_ignition_codegen, false,
|
|
|
|
"trace the codegen of ignition interpreter bytecode handlers")
|
2016-04-11 11:57:31 +00:00
|
|
|
DEFINE_BOOL(trace_ignition_dispatches, false,
|
|
|
|
"traces the dispatches to bytecode handlers by the ignition "
|
|
|
|
"interpreter")
|
2016-05-04 11:21:16 +00:00
|
|
|
DEFINE_STRING(trace_ignition_dispatches_output_file, nullptr,
|
2016-04-11 11:57:31 +00:00
|
|
|
"the file to which the bytecode handler dispatch table is "
|
2016-05-04 11:21:16 +00:00
|
|
|
"written (by default, the table is not written to a file)")
|
2015-07-23 14:21:26 +00:00
|
|
|
|
2010-12-07 11:31:57 +00:00
|
|
|
// Flags for Crankshaft.
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(crankshaft, true, "use crankshaft")
|
|
|
|
DEFINE_STRING(hydrogen_filter, "*", "optimization filter")
|
|
|
|
DEFINE_BOOL(use_gvn, true, "use hydrogen global value numbering")
|
|
|
|
DEFINE_INT(gvn_iterations, 3, "maximum number of GVN fix-point iterations")
|
|
|
|
DEFINE_BOOL(use_canonicalizing, true, "use hydrogen instruction canonicalizing")
|
|
|
|
DEFINE_BOOL(use_inlining, true, "use function inlining")
|
|
|
|
DEFINE_BOOL(use_escape_analysis, true, "use hydrogen escape analysis")
|
|
|
|
DEFINE_BOOL(use_allocation_folding, true, "use allocation folding")
|
|
|
|
DEFINE_BOOL(use_local_allocation_folding, false, "only fold in basic blocks")
|
|
|
|
DEFINE_BOOL(use_write_barrier_elimination, true,
|
2014-02-14 14:58:05 +00:00
|
|
|
"eliminate write barriers targeting allocations in optimized code")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_INT(max_inlining_levels, 5, "maximum number of inlining levels")
|
2015-02-03 15:02:43 +00:00
|
|
|
DEFINE_INT(max_inlined_source_size, 600,
|
2012-04-20 10:42:12 +00:00
|
|
|
"maximum source size in bytes considered for a single inlining")
|
2016-09-22 10:57:18 +00:00
|
|
|
DEFINE_INT(max_inlined_nodes, 200,
|
2012-04-20 10:42:12 +00:00
|
|
|
"maximum number of AST nodes considered for a single inlining")
|
2015-02-03 15:02:43 +00:00
|
|
|
DEFINE_INT(max_inlined_nodes_cumulative, 400,
|
2012-04-20 10:42:12 +00:00
|
|
|
"maximum cumulative number of AST nodes considered for inlining")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(loop_invariant_code_motion, true, "loop invariant code motion")
|
|
|
|
DEFINE_BOOL(fast_math, true, "faster (but maybe less accurate) math functions")
|
2016-02-15 15:21:31 +00:00
|
|
|
DEFINE_BOOL(collect_megamorphic_maps_from_stub_cache, false,
|
2011-11-18 14:08:57 +00:00
|
|
|
"crankshaft harvests type feedback from stub cache")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(hydrogen_stats, false, "print statistics for hydrogen")
|
|
|
|
DEFINE_BOOL(trace_check_elimination, false, "trace check elimination phase")
|
2015-03-17 09:38:37 +00:00
|
|
|
DEFINE_BOOL(trace_environment_liveness, false,
|
|
|
|
"trace liveness of local variable slots")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(trace_hydrogen, false, "trace generated hydrogen to file")
|
|
|
|
DEFINE_STRING(trace_hydrogen_filter, "*", "hydrogen tracing filter")
|
|
|
|
DEFINE_BOOL(trace_hydrogen_stubs, false, "trace generated hydrogen for stubs")
|
|
|
|
DEFINE_STRING(trace_hydrogen_file, NULL, "trace hydrogen to given file name")
|
|
|
|
DEFINE_STRING(trace_phase, "HLZ", "trace generated IR for specified phases")
|
|
|
|
DEFINE_BOOL(trace_inlining, false, "trace inlining decisions")
|
|
|
|
DEFINE_BOOL(trace_load_elimination, false, "trace load elimination")
|
|
|
|
DEFINE_BOOL(trace_store_elimination, false, "trace store elimination")
|
2016-08-09 20:00:25 +00:00
|
|
|
DEFINE_BOOL(turbo_verify_store_elimination, false,
|
|
|
|
"verify store elimination more rigorously")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(trace_alloc, false, "trace register allocator")
|
|
|
|
DEFINE_BOOL(trace_all_uses, false, "trace all use positions")
|
|
|
|
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")
|
|
|
|
DEFINE_BOOL(trace_removable_simulates, false, "trace removable simulates")
|
|
|
|
DEFINE_BOOL(trace_escape_analysis, false, "trace hydrogen escape analysis")
|
|
|
|
DEFINE_BOOL(trace_allocation_folding, false, "trace allocation folding")
|
|
|
|
DEFINE_BOOL(trace_track_allocation_sites, false,
|
2013-01-17 08:41:27 +00:00
|
|
|
"trace the tracking of allocation sites")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(trace_migration, false, "trace object migration")
|
|
|
|
DEFINE_BOOL(trace_generalization, false, "trace map generalization")
|
|
|
|
DEFINE_BOOL(stress_pointer_maps, false, "pointer map for every instruction")
|
|
|
|
DEFINE_BOOL(stress_environments, false, "environment for every instruction")
|
|
|
|
DEFINE_INT(deopt_every_n_times, 0,
|
2010-12-07 11:31:57 +00:00
|
|
|
"deoptimize every n times a deopt point is passed")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_INT(deopt_every_n_garbage_collections, 0,
|
2013-04-23 15:21:11 +00:00
|
|
|
"deoptimize every n garbage collections")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(print_deopt_stress, false, "print number of possible deopt points")
|
|
|
|
DEFINE_BOOL(trap_on_deopt, false, "put a break point before deoptimizing")
|
|
|
|
DEFINE_BOOL(trap_on_stub_deopt, false,
|
2013-08-09 08:24:29 +00:00
|
|
|
"put a break point before deoptimizing a stub")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(deoptimize_uncommon_cases, true, "deoptimize uncommon cases")
|
|
|
|
DEFINE_BOOL(polymorphic_inlining, true, "polymorphic inlining")
|
|
|
|
DEFINE_BOOL(use_osr, true, "use on-stack replacement")
|
|
|
|
DEFINE_BOOL(array_bounds_checks_elimination, true,
|
2012-04-25 14:32:27 +00:00
|
|
|
"perform array bounds checks elimination")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(trace_bce, false, "trace array bounds check elimination")
|
|
|
|
DEFINE_BOOL(array_index_dehoisting, true, "perform array index dehoisting")
|
|
|
|
DEFINE_BOOL(analyze_environment_liveness, true,
|
2013-06-04 16:41:24 +00:00
|
|
|
"analyze liveness of environment slots and zap dead values")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(load_elimination, true, "use load elimination")
|
|
|
|
DEFINE_BOOL(check_elimination, true, "use check elimination")
|
|
|
|
DEFINE_BOOL(store_elimination, false, "use store elimination")
|
|
|
|
DEFINE_BOOL(dead_code_elimination, true, "use dead code elimination")
|
|
|
|
DEFINE_BOOL(fold_constants, true, "use constant folding")
|
|
|
|
DEFINE_BOOL(trace_dead_code_elimination, false, "trace dead code elimination")
|
|
|
|
DEFINE_BOOL(unreachable_code_elimination, true, "eliminate unreachable code")
|
|
|
|
DEFINE_BOOL(trace_osr, false, "trace on-stack replacement")
|
|
|
|
DEFINE_INT(stress_runs, 0, "number of stress runs")
|
|
|
|
DEFINE_BOOL(lookup_sample_by_shared, true,
|
2012-06-14 14:06:22 +00:00
|
|
|
"when picking a function to optimize, watch for shared function "
|
|
|
|
"info, not JSFunction itself")
|
2015-12-17 11:40:05 +00:00
|
|
|
DEFINE_BOOL(flush_optimized_code_cache, false,
|
2013-05-16 08:39:24 +00:00
|
|
|
"flushes the cache of optimized code for closures on every GC")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(inline_construct, true, "inline constructor calls")
|
|
|
|
DEFINE_BOOL(inline_arguments, true, "inline functions with arguments object")
|
|
|
|
DEFINE_BOOL(inline_accessors, true, "inline JavaScript accessors")
|
2016-10-31 10:21:44 +00:00
|
|
|
DEFINE_BOOL(inline_into_try, true, "inline into try blocks")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_INT(escape_analysis_iterations, 2,
|
2013-10-16 09:16:56 +00:00
|
|
|
"maximum number of escape analysis fix-point iterations")
|
2010-12-07 11:31:57 +00:00
|
|
|
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(concurrent_recompilation, true,
|
2012-07-19 18:58:23 +00:00
|
|
|
"optimizing hot functions asynchronously on a separate thread")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(trace_concurrent_recompilation, false,
|
2013-08-22 16:14:37 +00:00
|
|
|
"track concurrent recompilation")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_INT(concurrent_recompilation_queue_length, 8,
|
2013-08-22 16:14:37 +00:00
|
|
|
"the length of the concurrent compilation queue")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_INT(concurrent_recompilation_delay, 0,
|
2013-03-05 16:22:08 +00:00
|
|
|
"artificial compilation delay in ms")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(block_concurrent_recompilation, false,
|
2013-10-14 14:15:22 +00:00
|
|
|
"block queued jobs until released")
|
2013-08-22 16:14:37 +00:00
|
|
|
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(omit_map_checks_for_leaf_maps, true,
|
2013-07-23 09:18:42 +00:00
|
|
|
"do not emit check maps for constant values that have a leaf map, "
|
|
|
|
"deoptimize the optimized code if the layout of the maps changes.")
|
2012-07-19 18:58:23 +00:00
|
|
|
|
2014-07-30 13:54:45 +00:00
|
|
|
// Flags for TurboFan.
|
2015-04-16 16:28:45 +00:00
|
|
|
DEFINE_BOOL(turbo, false, "enable TurboFan compiler")
|
2015-10-20 10:56:53 +00:00
|
|
|
DEFINE_IMPLICATION(turbo, turbo_asm_deoptimization)
|
2016-07-17 20:02:23 +00:00
|
|
|
DEFINE_IMPLICATION(turbo, turbo_loop_peeling)
|
2016-11-09 12:52:01 +00:00
|
|
|
DEFINE_IMPLICATION(turbo, turbo_escape)
|
2015-11-24 22:53:48 +00:00
|
|
|
DEFINE_BOOL(turbo_sp_frame_access, false,
|
|
|
|
"use stack pointer-relative access to frame wherever possible")
|
[turbofan] Deferred blocks splintering.
This change encompasses what is necessary to enable stack checks in loops without suffering large regressions.
Primarily, it consists of a new mechanism for dealing with deferred blocks by "splintering", rather than splitting, inside deferred blocks.
My initial change was splitting along deferred block boundaries, but the regression introduced by stackchecks wasn't resolved conclusively. After investigation, it appears that just splitting ranges along cold block boundaries leads to a greater opportunity for moves on the hot path, hence the suboptimal outcome.
The alternative "splinters" ranges rather than splitting them. While splitting creates 2 ranges and links them (parent-child), in contrast, splintering creates a new independent range with no parent-child relation to the original. The original range appears as if it has a liveness hole in the place of the splintered one. All thus obtained ranges are then register allocated with no change to the register allocator.
The splinters (cold blocks) do not conflict with the hot path ranges, by construction. The hot path ones have less pressure to split, because we remove a source of conflicts. After allocation, we merge the splinters back to their original ranges and continue the pipeline. We leverage the previous changes made for deferred blocks (determining where to spill, for example).
Review URL: https://codereview.chromium.org/1305393003
Cr-Commit-Position: refs/heads/master@{#30357}
2015-08-25 14:47:26 +00:00
|
|
|
DEFINE_BOOL(turbo_preprocess_ranges, true,
|
2015-08-04 14:49:44 +00:00
|
|
|
"run pre-register allocation heuristics")
|
[turbofan] Deferred blocks splintering.
This change encompasses what is necessary to enable stack checks in loops without suffering large regressions.
Primarily, it consists of a new mechanism for dealing with deferred blocks by "splintering", rather than splitting, inside deferred blocks.
My initial change was splitting along deferred block boundaries, but the regression introduced by stackchecks wasn't resolved conclusively. After investigation, it appears that just splitting ranges along cold block boundaries leads to a greater opportunity for moves on the hot path, hence the suboptimal outcome.
The alternative "splinters" ranges rather than splitting them. While splitting creates 2 ranges and links them (parent-child), in contrast, splintering creates a new independent range with no parent-child relation to the original. The original range appears as if it has a liveness hole in the place of the splintered one. All thus obtained ranges are then register allocated with no change to the register allocator.
The splinters (cold blocks) do not conflict with the hot path ranges, by construction. The hot path ones have less pressure to split, because we remove a source of conflicts. After allocation, we merge the splinters back to their original ranges and continue the pipeline. We leverage the previous changes made for deferred blocks (determining where to spill, for example).
Review URL: https://codereview.chromium.org/1305393003
Cr-Commit-Position: refs/heads/master@{#30357}
2015-08-25 14:47:26 +00:00
|
|
|
DEFINE_BOOL(turbo_loop_stackcheck, true, "enable stack checks in loops")
|
2015-04-16 16:28:45 +00:00
|
|
|
DEFINE_STRING(turbo_filter, "~~", "optimization filter for TurboFan compiler")
|
2014-07-30 13:54:45 +00:00
|
|
|
DEFINE_BOOL(trace_turbo, false, "trace generated TurboFan IR")
|
2014-11-24 11:54:59 +00:00
|
|
|
DEFINE_BOOL(trace_turbo_graph, false, "trace generated TurboFan graphs")
|
|
|
|
DEFINE_IMPLICATION(trace_turbo_graph, trace_turbo)
|
2014-10-14 08:43:33 +00:00
|
|
|
DEFINE_STRING(trace_turbo_cfg_file, NULL,
|
|
|
|
"trace turbo cfg graph (for C1 visualizer) to a given file name")
|
2014-10-28 13:14:53 +00:00
|
|
|
DEFINE_BOOL(trace_turbo_types, true, "trace TurboFan's types")
|
|
|
|
DEFINE_BOOL(trace_turbo_scheduler, false, "trace TurboFan's scheduler")
|
|
|
|
DEFINE_BOOL(trace_turbo_reduction, false, "trace TurboFan's various reducers")
|
2016-07-12 03:54:55 +00:00
|
|
|
DEFINE_BOOL(trace_turbo_trimming, false, "trace TurboFan's graph trimmer")
|
2014-11-26 12:41:46 +00:00
|
|
|
DEFINE_BOOL(trace_turbo_jt, false, "trace TurboFan's jump threading")
|
2015-04-16 06:04:43 +00:00
|
|
|
DEFINE_BOOL(trace_turbo_ceq, false, "trace TurboFan's control equivalence")
|
2016-07-27 05:50:39 +00:00
|
|
|
DEFINE_BOOL(trace_turbo_loop, false, "trace TurboFan's loop optimizations")
|
2014-12-02 11:07:17 +00:00
|
|
|
DEFINE_BOOL(turbo_asm, true, "enable TurboFan for asm.js code")
|
2015-05-21 11:33:42 +00:00
|
|
|
DEFINE_BOOL(turbo_asm_deoptimization, false,
|
|
|
|
"enable deoptimization in TurboFan for asm.js code")
|
2015-01-15 12:17:23 +00:00
|
|
|
DEFINE_BOOL(turbo_verify, DEBUG_BOOL, "verify TurboFan graphs at each phase")
|
2016-10-14 14:22:15 +00:00
|
|
|
DEFINE_STRING(turbo_verify_machine_graph, nullptr,
|
|
|
|
"verify TurboFan machine graph before instruction selection")
|
2014-07-30 13:54:45 +00:00
|
|
|
DEFINE_BOOL(turbo_stats, false, "print TurboFan statistics")
|
2016-06-13 09:35:37 +00:00
|
|
|
DEFINE_BOOL(turbo_stats_nvp, false,
|
|
|
|
"print TurboFan statistics in machine-readable format")
|
2015-02-03 14:50:40 +00:00
|
|
|
DEFINE_BOOL(turbo_splitting, true, "split nodes during scheduling in TurboFan")
|
2016-07-13 04:49:00 +00:00
|
|
|
DEFINE_BOOL(turbo_type_feedback, true,
|
2016-06-02 09:20:50 +00:00
|
|
|
"use typed feedback for representation inference in Turbofan")
|
2015-09-25 11:33:28 +00:00
|
|
|
DEFINE_BOOL(function_context_specialization, false,
|
|
|
|
"enable function context specialization in TurboFan")
|
2016-02-23 09:04:40 +00:00
|
|
|
DEFINE_BOOL(turbo_inlining, true, "enable inlining in TurboFan")
|
2014-08-20 13:05:03 +00:00
|
|
|
DEFINE_BOOL(trace_turbo_inlining, false, "trace TurboFan inlining")
|
2016-07-05 12:19:48 +00:00
|
|
|
DEFINE_BOOL(turbo_load_elimination, true, "enable load elimination in TurboFan")
|
|
|
|
DEFINE_BOOL(trace_turbo_load_elimination, false,
|
|
|
|
"trace TurboFan load elimination")
|
2014-10-28 17:29:41 +00:00
|
|
|
DEFINE_BOOL(loop_assignment_analysis, true, "perform loop assignment analysis")
|
2014-09-29 07:29:14 +00:00
|
|
|
DEFINE_BOOL(turbo_profiling, false, "enable profiling in TurboFan")
|
2015-01-15 12:17:23 +00:00
|
|
|
DEFINE_BOOL(turbo_verify_allocation, DEBUG_BOOL,
|
|
|
|
"verify register allocation in TurboFan")
|
2014-12-12 11:15:13 +00:00
|
|
|
DEFINE_BOOL(turbo_move_optimization, true, "optimize gap moves in TurboFan")
|
2015-01-12 11:39:48 +00:00
|
|
|
DEFINE_BOOL(turbo_jt, true, "enable jump threading in TurboFan")
|
2015-01-20 09:45:02 +00:00
|
|
|
DEFINE_BOOL(turbo_stress_loop_peeling, false,
|
|
|
|
"stress loop peeling optimization")
|
2016-07-15 10:23:29 +00:00
|
|
|
DEFINE_BOOL(turbo_loop_peeling, false, "Turbofan loop peeling")
|
2016-08-12 11:04:32 +00:00
|
|
|
DEFINE_BOOL(turbo_loop_variable, true, "Turbofan loop variable optimization")
|
2015-02-24 07:41:25 +00:00
|
|
|
DEFINE_BOOL(turbo_cf_optimization, true, "optimize control flow in TurboFan")
|
2015-04-29 05:54:41 +00:00
|
|
|
DEFINE_BOOL(turbo_frame_elision, true, "elide frames in TurboFan")
|
2016-05-18 13:49:05 +00:00
|
|
|
DEFINE_BOOL(turbo_escape, false, "enable escape analysis")
|
2015-12-15 14:51:43 +00:00
|
|
|
DEFINE_BOOL(turbo_instruction_scheduling, false,
|
|
|
|
"enable instruction scheduling in TurboFan")
|
2016-02-19 14:53:14 +00:00
|
|
|
DEFINE_BOOL(turbo_stress_instruction_scheduling, false,
|
|
|
|
"randomly schedule instructions to stress dependency tracking")
|
2016-09-21 05:49:58 +00:00
|
|
|
DEFINE_BOOL(turbo_store_elimination, true,
|
2016-06-23 15:13:32 +00:00
|
|
|
"enable store-store elimination in TurboFan")
|
2014-07-30 13:54:45 +00:00
|
|
|
|
2016-07-28 22:15:00 +00:00
|
|
|
// Flags to help platform porters
|
|
|
|
DEFINE_BOOL(minimal, false,
|
|
|
|
"simplifies execution model to make porting "
|
|
|
|
"easier (e.g. always use Ignition, never use Crankshaft")
|
|
|
|
DEFINE_IMPLICATION(minimal, ignition)
|
|
|
|
DEFINE_NEG_IMPLICATION(minimal, crankshaft)
|
|
|
|
DEFINE_NEG_IMPLICATION(minimal, use_ic)
|
|
|
|
|
2015-08-18 15:04:02 +00:00
|
|
|
// Flags for native WebAssembly.
|
2015-12-17 14:52:27 +00:00
|
|
|
DEFINE_BOOL(expose_wasm, false, "expose WASM interface to JavaScript")
|
2016-06-10 11:58:35 +00:00
|
|
|
DEFINE_INT(wasm_num_compilation_tasks, 10,
|
2016-05-12 11:58:27 +00:00
|
|
|
"number of parallel compilation tasks for wasm")
|
2016-03-10 12:36:42 +00:00
|
|
|
DEFINE_BOOL(trace_wasm_encoder, false, "trace encoding of wasm code")
|
2015-08-18 15:04:02 +00:00
|
|
|
DEFINE_BOOL(trace_wasm_decoder, false, "trace decoding of wasm code")
|
2015-10-28 05:40:58 +00:00
|
|
|
DEFINE_BOOL(trace_wasm_decode_time, false, "trace decoding time of wasm code")
|
2015-08-18 15:04:02 +00:00
|
|
|
DEFINE_BOOL(trace_wasm_compiler, false, "trace compiling of wasm code")
|
2016-05-25 08:32:37 +00:00
|
|
|
DEFINE_BOOL(trace_wasm_interpreter, false, "trace interpretation of wasm code")
|
2016-03-17 08:21:50 +00:00
|
|
|
DEFINE_INT(trace_wasm_ast_start, 0,
|
|
|
|
"start function for WASM AST trace (inclusive)")
|
|
|
|
DEFINE_INT(trace_wasm_ast_end, 0, "end function for WASM AST trace (exclusive)")
|
|
|
|
DEFINE_INT(skip_compiling_wasm_funcs, 0, "start compiling at function N")
|
2015-08-18 15:04:02 +00:00
|
|
|
DEFINE_BOOL(wasm_break_on_decoder_error, false,
|
|
|
|
"debug break when wasm decoder encounters an error")
|
2016-03-29 12:50:36 +00:00
|
|
|
DEFINE_BOOL(wasm_loop_assignment_analysis, true,
|
2016-03-14 14:13:22 +00:00
|
|
|
"perform loop assignment analysis for WASM")
|
2015-08-18 15:04:02 +00:00
|
|
|
|
2016-05-12 16:35:50 +00:00
|
|
|
DEFINE_BOOL(validate_asm, false, "validate asm.js modules before compiling")
|
2016-02-01 18:25:17 +00:00
|
|
|
|
2016-03-21 21:41:22 +00:00
|
|
|
DEFINE_BOOL(dump_wasm_module, false, "dump WASM module bytes")
|
|
|
|
DEFINE_STRING(dump_wasm_module_path, NULL, "directory to dump wasm modules to")
|
2016-02-16 03:02:51 +00:00
|
|
|
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_INT(typed_array_max_size_in_heap, 64,
|
|
|
|
"threshold for in-heap typed array")
|
2014-03-26 12:50:13 +00:00
|
|
|
|
2016-07-16 03:49:45 +00:00
|
|
|
DEFINE_BOOL(wasm_simd_prototype, false,
|
|
|
|
"enable prototype simd opcodes for wasm")
|
2016-08-11 13:14:51 +00:00
|
|
|
DEFINE_BOOL(wasm_eh_prototype, false,
|
|
|
|
"enable prototype exception handling opcodes for wasm")
|
2016-09-27 20:46:10 +00:00
|
|
|
DEFINE_BOOL(wasm_mv_prototype, false,
|
|
|
|
"enable prototype multi-value support for wasm")
|
2016-10-26 20:28:05 +00:00
|
|
|
DEFINE_BOOL(wasm_atomics_prototype, false,
|
|
|
|
"enable prototype atomic opcodes for wasm")
|
2016-06-22 00:51:58 +00:00
|
|
|
|
2016-09-09 17:40:37 +00:00
|
|
|
DEFINE_BOOL(wasm_trap_handler, false,
|
|
|
|
"use signal handlers to catch out of bounds memory access in wasm"
|
|
|
|
" (currently Linux x86_64 only)")
|
|
|
|
|
2013-12-06 09:52:40 +00:00
|
|
|
// Profiler flags.
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_INT(frame_count, 1, "number of stack frames inspected by the profiler")
|
|
|
|
// 0x1800 fits in the immediate field of an ARM instruction.
|
|
|
|
DEFINE_INT(interrupt_budget, 0x1800,
|
2012-02-14 14:00:31 +00:00
|
|
|
"execution budget before interrupt is triggered")
|
2016-02-16 10:59:38 +00:00
|
|
|
DEFINE_INT(type_info_threshold, 25,
|
2012-02-20 12:57:23 +00:00
|
|
|
"percentage of ICs that must have type info to allow optimization")
|
2014-08-05 17:06:01 +00:00
|
|
|
DEFINE_INT(generic_ic_threshold, 30,
|
|
|
|
"max percentage of megamorphic/generic ICs to allow optimization")
|
2014-11-21 17:28:18 +00:00
|
|
|
DEFINE_INT(self_opt_count, 130, "call count before self-optimization")
|
2012-02-09 13:30:01 +00:00
|
|
|
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(trace_opt_verbose, false, "extra verbose compilation tracing")
|
|
|
|
DEFINE_IMPLICATION(trace_opt_verbose, trace_opt)
|
2012-02-20 12:57:23 +00:00
|
|
|
|
2009-10-08 14:27:46 +00:00
|
|
|
// assembler-ia32.cc / assembler-arm.cc / assembler-x64.cc
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(debug_code, false, "generate extra code (assertions) for debugging")
|
|
|
|
DEFINE_BOOL(code_comments, false, "emit comments in code disassembly")
|
|
|
|
DEFINE_BOOL(enable_sse3, true, "enable use of SSE3 instructions if available")
|
2016-09-12 06:24:06 +00:00
|
|
|
DEFINE_BOOL(enable_ssse3, true, "enable use of SSSE3 instructions if available")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(enable_sse4_1, true,
|
2010-09-28 14:56:36 +00:00
|
|
|
"enable use of SSE4.1 instructions if available")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(enable_sahf, true,
|
2009-10-08 14:27:46 +00:00
|
|
|
"enable use of SAHF instruction if available (X64 only)")
|
2014-11-26 05:31:41 +00:00
|
|
|
DEFINE_BOOL(enable_avx, true, "enable use of AVX instructions if available")
|
|
|
|
DEFINE_BOOL(enable_fma3, true, "enable use of FMA3 instructions if available")
|
2015-04-08 07:15:51 +00:00
|
|
|
DEFINE_BOOL(enable_bmi1, true, "enable use of BMI1 instructions if available")
|
|
|
|
DEFINE_BOOL(enable_bmi2, true, "enable use of BMI2 instructions if available")
|
|
|
|
DEFINE_BOOL(enable_lzcnt, true, "enable use of LZCNT instruction if available")
|
|
|
|
DEFINE_BOOL(enable_popcnt, true,
|
|
|
|
"enable use of POPCNT instruction if available")
|
2016-08-30 10:01:50 +00:00
|
|
|
DEFINE_STRING(arm_arch, ARM_ARCH_DEFAULT,
|
|
|
|
"generate instructions for the selected ARM architecture if "
|
|
|
|
"available: armv6, armv7, armv7+sudiv or armv8")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(enable_vldr_imm, false,
|
2012-12-28 13:34:15 +00:00
|
|
|
"enable use of constant pools for double immediate (ARM only)")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(force_long_branches, false,
|
2015-01-16 07:42:00 +00:00
|
|
|
"force all emitted branches to be in long mode (MIPS/PPC only)")
|
2015-01-20 14:59:47 +00:00
|
|
|
DEFINE_STRING(mcpu, "auto", "enable optimization for specific cpu")
|
2008-09-12 10:19:33 +00:00
|
|
|
|
2016-08-30 10:01:50 +00:00
|
|
|
// Deprecated ARM flags (replaced by arm_arch).
|
|
|
|
DEFINE_MAYBE_BOOL(enable_armv7, "deprecated (use --arm_arch instead)")
|
|
|
|
DEFINE_MAYBE_BOOL(enable_vfp3, "deprecated (use --arm_arch instead)")
|
|
|
|
DEFINE_MAYBE_BOOL(enable_32dregs, "deprecated (use --arm_arch instead)")
|
|
|
|
DEFINE_MAYBE_BOOL(enable_neon, "deprecated (use --arm_arch instead)")
|
|
|
|
DEFINE_MAYBE_BOOL(enable_sudiv, "deprecated (use --arm_arch instead)")
|
|
|
|
DEFINE_MAYBE_BOOL(enable_armv8, "deprecated (use --arm_arch instead)")
|
|
|
|
|
2016-07-27 13:24:28 +00:00
|
|
|
// regexp-macro-assembler-*.cc
|
|
|
|
DEFINE_BOOL(enable_regexp_unaligned_accesses, true,
|
|
|
|
"enable unaligned accesses for the regexp engine")
|
|
|
|
|
2016-10-05 08:40:30 +00:00
|
|
|
// api.cc
|
|
|
|
DEFINE_BOOL(script_streaming, true, "enable parsing on background")
|
|
|
|
|
2008-09-12 10:19:33 +00:00
|
|
|
// bootstrapper.cc
|
2014-07-02 14:00:16 +00:00
|
|
|
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_free_buffer, false, "expose freeBuffer extension")
|
|
|
|
DEFINE_BOOL(expose_gc, false, "expose gc extension")
|
|
|
|
DEFINE_STRING(expose_gc_as, NULL,
|
2013-04-23 16:30:51 +00:00
|
|
|
"expose gc extension under the specified name")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_IMPLICATION(expose_gc_as, expose_gc)
|
|
|
|
DEFINE_BOOL(expose_externalize_string, false,
|
2010-06-17 16:19:28 +00:00
|
|
|
"expose externalize string extension")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(expose_trigger_failure, false, "expose trigger-failure extension")
|
|
|
|
DEFINE_INT(stack_trace_limit, 10, "number of stack frames to capture")
|
|
|
|
DEFINE_BOOL(builtins_in_stack_traces, false,
|
2011-10-20 12:31:33 +00:00
|
|
|
"show built-in functions in stack traces")
|
2008-09-12 10:19:33 +00:00
|
|
|
|
2016-07-18 15:34:25 +00:00
|
|
|
// builtins.cc
|
|
|
|
DEFINE_BOOL(allow_unsafe_function_constructor, false,
|
|
|
|
"allow invoking the function constructor without security checks")
|
|
|
|
|
2008-09-12 10:19:33 +00:00
|
|
|
// builtins-ia32.cc
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(inline_new, true, "use fast inline allocation")
|
2008-09-12 10:19:33 +00:00
|
|
|
|
|
|
|
// codegen-ia32.cc / codegen-arm.cc
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(trace_codegen, false,
|
2013-05-24 10:57:59 +00:00
|
|
|
"print name of functions for which code is generated")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(trace, false, "trace function calls")
|
|
|
|
DEFINE_BOOL(mask_constants_with_cookie, true,
|
2010-10-29 06:15:34 +00:00
|
|
|
"use random jit cookie to mask large constants")
|
2008-09-12 10:19:33 +00:00
|
|
|
|
|
|
|
// codegen.cc
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(lazy, true, "use lazy compilation")
|
|
|
|
DEFINE_BOOL(trace_opt, false, "trace lazy optimization")
|
|
|
|
DEFINE_BOOL(trace_opt_stats, false, "trace lazy optimization statistics")
|
2016-06-22 22:21:03 +00:00
|
|
|
DEFINE_BOOL(trace_file_names, false,
|
|
|
|
"include file names in trace-opt/trace-deopt output")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(opt, true, "use adaptive optimizations")
|
|
|
|
DEFINE_BOOL(always_opt, false, "always try to optimize functions")
|
|
|
|
DEFINE_BOOL(always_osr, false, "always try to OSR functions")
|
|
|
|
DEFINE_BOOL(prepare_always_opt, false, "prepare for turning on always opt")
|
|
|
|
DEFINE_BOOL(trace_deopt, false, "trace optimize function deoptimization")
|
|
|
|
DEFINE_BOOL(trace_stub_failures, false,
|
2013-02-05 16:28:36 +00:00
|
|
|
"trace deoptimization of generated code stubs")
|
2008-09-12 10:19:33 +00:00
|
|
|
|
2014-10-24 12:41:52 +00:00
|
|
|
DEFINE_BOOL(serialize_toplevel, true, "enable caching of toplevel scripts")
|
2016-03-14 18:55:41 +00:00
|
|
|
DEFINE_BOOL(serialize_eager, false, "compile eagerly when caching scripts")
|
|
|
|
DEFINE_BOOL(serialize_age_code, false, "pre age code in the code cache")
|
2014-12-03 09:12:28 +00:00
|
|
|
DEFINE_BOOL(trace_serializer, false, "print code serializer trace")
|
2016-11-15 08:58:54 +00:00
|
|
|
#ifdef DEBUG
|
|
|
|
DEFINE_BOOL(external_reference_stats, false,
|
|
|
|
"print statistics on external references used during serialization")
|
|
|
|
#endif // DEBUG
|
2014-07-08 09:04:08 +00:00
|
|
|
|
2008-09-12 10:19:33 +00:00
|
|
|
// compiler.cc
|
2014-07-02 14:00:16 +00:00
|
|
|
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")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_INT(max_opt_count, 10,
|
2012-08-16 11:40:03 +00:00
|
|
|
"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
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(compilation_cache, true, "enable compilation cache")
|
2009-05-20 20:28:33 +00:00
|
|
|
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(cache_prototype_transitions, true, "cache prototype transitions")
|
2011-04-26 09:44:55 +00:00
|
|
|
|
2013-08-26 07:17:12 +00:00
|
|
|
// cpu-profiler.cc
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_INT(cpu_profiler_sampling_interval, 1000,
|
2013-08-26 07:17:12 +00:00
|
|
|
"CPU profiler sampling interval in microseconds")
|
|
|
|
|
2015-12-15 09:53:55 +00:00
|
|
|
// Array abuse tracing
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(trace_js_array_abuse, false,
|
2013-02-08 14:32:38 +00:00
|
|
|
"trace out-of-bounds accesses to JS arrays")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(trace_external_array_abuse, false,
|
2013-02-08 14:32:38 +00:00
|
|
|
"trace out-of-bounds-accesses to external arrays")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(trace_array_abuse, false,
|
2013-02-08 14:32:38 +00:00
|
|
|
"trace out-of-bounds accesses to all arrays")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_IMPLICATION(trace_array_abuse, trace_js_array_abuse)
|
|
|
|
DEFINE_IMPLICATION(trace_array_abuse, trace_external_array_abuse)
|
2015-12-15 09:53:55 +00:00
|
|
|
|
|
|
|
// debugger
|
|
|
|
DEFINE_BOOL(trace_debug_json, false, "trace debugging JSON request/response")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(enable_liveedit, true, "enable liveedit experimental feature")
|
|
|
|
DEFINE_BOOL(hard_abort, true, "abort by crashing")
|
2008-09-12 10:19:33 +00:00
|
|
|
|
2011-02-11 14:26:56 +00:00
|
|
|
// execution.cc
|
2015-02-01 08:08:33 +00:00
|
|
|
DEFINE_INT(stack_size, V8_DEFAULT_STACK_SIZE_KB,
|
|
|
|
"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
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_INT(max_stack_trace_source_length, 300,
|
2008-09-12 10:19:33 +00:00
|
|
|
"maximum length of function source code printed in a stack trace.")
|
|
|
|
|
2010-09-15 10:14:25 +00:00
|
|
|
// full-codegen.cc
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(always_inline_smi_code, false,
|
2010-09-15 10:14:25 +00:00
|
|
|
"always inline smi code in non-opt code")
|
2016-02-23 13:40:38 +00:00
|
|
|
DEFINE_BOOL(verify_operand_stack_depth, false,
|
|
|
|
"emit debug code that verifies the static tracking of the operand "
|
|
|
|
"stack depth")
|
2010-09-15 10:14:25 +00:00
|
|
|
|
2008-09-12 10:19:33 +00:00
|
|
|
// heap.cc
|
2015-02-01 08:08:33 +00:00
|
|
|
DEFINE_INT(min_semi_space_size, 0,
|
|
|
|
"min size of a semi-space (in MBytes), the new space consists of two"
|
|
|
|
"semi-spaces")
|
|
|
|
DEFINE_INT(max_semi_space_size, 0,
|
|
|
|
"max size of a semi-space (in MBytes), the new space consists of two"
|
|
|
|
"semi-spaces")
|
2014-11-21 12:14:22 +00:00
|
|
|
DEFINE_INT(semi_space_growth_factor, 2, "factor by which to grow the new space")
|
2014-11-27 10:52:47 +00:00
|
|
|
DEFINE_BOOL(experimental_new_space_growth_heuristic, false,
|
|
|
|
"Grow the new space based on the percentage of survivors instead "
|
|
|
|
"of their absolute value.")
|
2015-02-01 08:08:33 +00:00
|
|
|
DEFINE_INT(max_old_space_size, 0, "max size of the old space (in Mbytes)")
|
|
|
|
DEFINE_INT(initial_old_space_size, 0, "initial old space size (in Mbytes)")
|
|
|
|
DEFINE_INT(max_executable_size, 0, "max size of executable memory (in Mbytes)")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(gc_global, false, "always perform global GCs")
|
|
|
|
DEFINE_INT(gc_interval, -1, "garbage collect after <n> allocations")
|
2015-03-06 12:36:16 +00:00
|
|
|
DEFINE_INT(retain_maps_for_n_gc, 2,
|
|
|
|
"keeps maps alive for <n> old space garbage collections")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(trace_gc, false,
|
2008-09-12 10:19:33 +00:00
|
|
|
"print one trace line following each garbage collection")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(trace_gc_nvp, false,
|
2010-05-18 16:50:17 +00:00
|
|
|
"print one detailed trace line in name=value format "
|
|
|
|
"after each garbage collection")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(trace_gc_ignore_scavenger, false,
|
2012-08-07 08:19:11 +00:00
|
|
|
"do not print trace line after scavenger collection")
|
2014-09-01 12:06:16 +00:00
|
|
|
DEFINE_BOOL(trace_idle_notification, false,
|
|
|
|
"print one trace line following each idle notification")
|
2014-11-17 09:16:14 +00:00
|
|
|
DEFINE_BOOL(trace_idle_notification_verbose, false,
|
|
|
|
"prints the heap state used by the idle notification")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(print_max_heap_committed, false,
|
2013-11-05 11:59:42 +00:00
|
|
|
"print statistics of the maximum memory committed for the heap "
|
|
|
|
"in name=value format on exit")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(trace_gc_verbose, false,
|
2009-07-13 21:24:54 +00:00
|
|
|
"print more details following each garbage collection")
|
2015-04-30 12:14:34 +00:00
|
|
|
DEFINE_INT(trace_allocation_stack_interval, -1,
|
|
|
|
"print stack trace after <n> free-list allocations")
|
2015-03-24 15:02:21 +00:00
|
|
|
DEFINE_BOOL(trace_fragmentation, false, "report fragmentation for old space")
|
|
|
|
DEFINE_BOOL(trace_fragmentation_verbose, false,
|
|
|
|
"report fragmentation for old space (detailed)")
|
2016-03-17 14:18:14 +00:00
|
|
|
DEFINE_BOOL(trace_evacuation, false, "report evacuation statistics")
|
2015-07-24 10:31:20 +00:00
|
|
|
DEFINE_BOOL(trace_mutator_utilization, false,
|
|
|
|
"print mutator utilization, allocation speed, gc speed")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(weak_embedded_maps_in_optimized_code, true,
|
2013-01-28 10:25:38 +00:00
|
|
|
"make maps embedded in optimized code weak")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(weak_embedded_objects_in_optimized_code, true,
|
2013-10-04 07:25:24 +00:00
|
|
|
"make objects embedded in optimized code weak")
|
2015-07-01 08:46:14 +00:00
|
|
|
DEFINE_BOOL(flush_code, true, "flush code that we expect not to use again")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(trace_code_flushing, false, "trace code flushing progress")
|
|
|
|
DEFINE_BOOL(age_code, true,
|
2012-11-08 12:18:11 +00:00
|
|
|
"track un-executed functions to age code and flush only "
|
2013-06-19 17:00:01 +00:00
|
|
|
"old code (required for code flushing)")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(incremental_marking, true, "use incremental marking")
|
2016-11-15 13:31:32 +00:00
|
|
|
DEFINE_BOOL(incremental_marking_wrappers, true,
|
2016-08-18 08:45:25 +00:00
|
|
|
"use incremental marking for marking wrappers")
|
2015-10-29 14:15:20 +00:00
|
|
|
DEFINE_INT(min_progress_during_incremental_marking_finalization, 32,
|
2015-10-28 12:05:29 +00:00
|
|
|
"keep finalizing incremental marking as long as we discover at "
|
2015-03-16 12:51:47 +00:00
|
|
|
"least this many unmarked objects")
|
2015-10-28 12:05:29 +00:00
|
|
|
DEFINE_INT(max_incremental_marking_finalization_rounds, 3,
|
|
|
|
"at most try this many times to finalize incremental marking")
|
2016-11-11 15:48:23 +00:00
|
|
|
DEFINE_BOOL(minor_mc, false, "perform young generation mark compact GCs")
|
|
|
|
DEFINE_NEG_IMPLICATION(minor_mc, incremental_marking)
|
2016-09-14 02:36:16 +00:00
|
|
|
DEFINE_BOOL(black_allocation, false, "use black allocation")
|
2014-11-17 09:39:42 +00:00
|
|
|
DEFINE_BOOL(concurrent_sweeping, true, "use concurrent sweeping")
|
2015-11-18 20:05:03 +00:00
|
|
|
DEFINE_BOOL(parallel_compaction, true, "use parallel compaction")
|
2016-03-16 19:43:09 +00:00
|
|
|
DEFINE_BOOL(parallel_pointer_update, true,
|
2016-03-10 12:18:25 +00:00
|
|
|
"use parallel pointer update during compaction")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(trace_incremental_marking, false,
|
2011-09-19 18:36:47 +00:00
|
|
|
"trace progress of the incremental marking")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(track_gc_object_stats, false,
|
2012-07-13 12:22:09 +00:00
|
|
|
"track object counts and memory usage")
|
2015-04-16 13:30:37 +00:00
|
|
|
DEFINE_BOOL(trace_gc_object_stats, false,
|
|
|
|
"trace object counts and memory usage")
|
2016-11-08 03:13:42 +00:00
|
|
|
DEFINE_INT(gc_stats, 0, "Used by tracing internally to enable gc statistics")
|
2015-04-16 13:30:37 +00:00
|
|
|
DEFINE_IMPLICATION(trace_gc_object_stats, track_gc_object_stats)
|
2016-11-08 03:13:42 +00:00
|
|
|
DEFINE_VALUE_IMPLICATION(track_gc_object_stats, gc_stats, 1)
|
|
|
|
DEFINE_VALUE_IMPLICATION(trace_gc_object_stats, gc_stats, 1)
|
2016-08-16 19:26:18 +00:00
|
|
|
DEFINE_NEG_IMPLICATION(trace_gc_object_stats, incremental_marking)
|
2015-02-17 13:21:50 +00:00
|
|
|
DEFINE_BOOL(track_detached_contexts, true,
|
2015-02-05 09:35:47 +00:00
|
|
|
"track native contexts that are expected to be garbage collected")
|
2015-02-17 13:21:50 +00:00
|
|
|
DEFINE_BOOL(trace_detached_contexts, false,
|
|
|
|
"trace native contexts that are expected to be garbage collected")
|
|
|
|
DEFINE_IMPLICATION(trace_detached_contexts, track_detached_contexts)
|
2012-10-12 11:41:14 +00:00
|
|
|
#ifdef VERIFY_HEAP
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(verify_heap, false, "verify heap pointers before and after GC")
|
2012-10-12 11:41:14 +00:00
|
|
|
#endif
|
2016-01-08 08:33:48 +00:00
|
|
|
DEFINE_BOOL(move_object_start, true, "enable moving of object starts")
|
2015-10-02 15:16:36 +00:00
|
|
|
DEFINE_BOOL(memory_reducer, true, "use memory reducer")
|
2015-12-04 08:58:46 +00:00
|
|
|
DEFINE_INT(heap_growing_percent, 0,
|
|
|
|
"specifies heap growing factor as (1 + heap_growing_percent/100)")
|
2008-09-12 10:19:33 +00:00
|
|
|
|
2016-11-15 14:39:59 +00:00
|
|
|
// spaces.cc
|
|
|
|
DEFINE_INT(v8_os_page_size, 0, "override OS page size (in KBytes)")
|
|
|
|
|
2016-08-03 13:38:43 +00:00
|
|
|
// execution.cc, messages.cc
|
2016-08-04 08:47:17 +00:00
|
|
|
DEFINE_BOOL(clear_exceptions_on_js_entry, false,
|
2016-08-03 13:38:43 +00:00
|
|
|
"clear pending exceptions when entering JavaScript")
|
|
|
|
|
2015-05-07 10:03:35 +00:00
|
|
|
// counters.cc
|
|
|
|
DEFINE_INT(histogram_interval, 600000,
|
|
|
|
"time interval in ms for aggregating memory histograms")
|
|
|
|
|
2016-03-09 17:54:07 +00:00
|
|
|
// global-handles.cc
|
|
|
|
DEFINE_BOOL(trace_object_groups, false,
|
|
|
|
"print object groups detected during each garbage collection")
|
2013-10-18 10:59:55 +00:00
|
|
|
|
|
|
|
// heap-snapshot-generator.cc
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(heap_profiler_trace_objects, false,
|
2013-10-18 10:59:55 +00:00
|
|
|
"Dump heap object allocations/movements/size_updates")
|
|
|
|
|
|
|
|
|
2016-01-22 16:36:40 +00:00
|
|
|
// sampling-heap-profiler.cc
|
|
|
|
DEFINE_BOOL(sampling_heap_profiler_suppress_randomness, false,
|
|
|
|
"Use constant sample intervals to eliminate test flakiness")
|
|
|
|
|
|
|
|
|
2009-08-13 12:03:42 +00:00
|
|
|
// v8.cc
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(use_idle_notification, true,
|
2009-08-13 12:03:42 +00:00
|
|
|
"Use idle notification to reduce memory footprint.")
|
2008-09-12 10:19:33 +00:00
|
|
|
// ic.cc
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(use_ic, true, "use inline caching")
|
2014-07-08 08:28:08 +00:00
|
|
|
DEFINE_BOOL(trace_ic, false, "trace inline cache state transitions")
|
2016-10-12 11:56:42 +00:00
|
|
|
DEFINE_BOOL_READONLY(tf_load_ic_stub, true, "use TF LoadIC stub")
|
2016-09-27 11:42:06 +00:00
|
|
|
DEFINE_BOOL(tf_store_ic_stub, true, "use TF StoreIC stub")
|
2008-09-12 10:19:33 +00:00
|
|
|
|
|
|
|
// macro-assembler-ia32.cc
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(native_code_counters, false,
|
2008-09-12 10:19:33 +00:00
|
|
|
"generate extra code for manipulating stats counters")
|
|
|
|
|
|
|
|
// mark-compact.cc
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(always_compact, false, "Perform compaction on every full GC")
|
|
|
|
DEFINE_BOOL(never_compact, false,
|
2008-09-12 10:19:33 +00:00
|
|
|
"Never perform compaction on full GC - testing only")
|
2015-07-01 09:44:49 +00:00
|
|
|
DEFINE_BOOL(compact_code_space, true, "Compact code space on full collections")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(cleanup_code_caches_at_gc, true,
|
2011-05-18 13:17:29 +00:00
|
|
|
"Flush inline caches prior to mark compact collection and "
|
|
|
|
"flush code caches in maps during mark compact cycle.")
|
2014-07-02 14:00:16 +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.")
|
2015-06-30 16:28:59 +00:00
|
|
|
DEFINE_BOOL(zap_code_space, DEBUG_BOOL,
|
2014-02-27 09:36:29 +00:00
|
|
|
"Zap free memory in code space with 0xCC while sweeping.")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_INT(random_seed, 0,
|
2010-03-24 10:32:23 +00:00
|
|
|
"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
|
2015-04-17 12:16:12 +00:00
|
|
|
DEFINE_BOOL(trace_weak_arrays, false, "Trace WeakFixedArray usage")
|
|
|
|
DEFINE_BOOL(trace_prototype_users, false,
|
|
|
|
"Trace updates to prototype user tracking")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(use_verbose_printer, true, "allows verbose printing")
|
2016-03-10 15:02:15 +00:00
|
|
|
DEFINE_BOOL(trace_for_in_enumerate, false, "Trace for-in enumerate slow-paths")
|
2014-11-07 16:03:11 +00:00
|
|
|
#if TRACE_MAPS
|
|
|
|
DEFINE_BOOL(trace_maps, false, "trace map creation")
|
|
|
|
#endif
|
2010-12-20 10:38:19 +00:00
|
|
|
|
2008-09-12 10:19:33 +00:00
|
|
|
// parser.cc
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(allow_natives_syntax, false, "allow natives syntax")
|
|
|
|
DEFINE_BOOL(trace_parse, false, "trace parsing and preparsing")
|
2016-10-18 08:00:03 +00:00
|
|
|
DEFINE_BOOL(trace_preparse, false, "trace preparsing decisions")
|
2016-09-27 12:47:44 +00:00
|
|
|
DEFINE_BOOL(lazy_inner_functions, false, "enable lazy parsing inner functions")
|
2008-09-12 10:19:33 +00:00
|
|
|
|
2014-03-21 09:28:26 +00:00
|
|
|
// simulator-arm.cc, simulator-arm64.cc and simulator-mips.cc
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(trace_sim, false, "Trace simulator execution")
|
|
|
|
DEFINE_BOOL(debug_sim, false, "Enable debugging the simulator")
|
|
|
|
DEFINE_BOOL(check_icache, false,
|
2011-10-28 08:14:46 +00:00
|
|
|
"Check icache flushes in ARM and MIPS simulator")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_INT(stop_sim_at, 0, "Simulator stop after x number of instructions")
|
2015-01-16 07:42:00 +00:00
|
|
|
#if defined(V8_TARGET_ARCH_ARM64) || defined(V8_TARGET_ARCH_MIPS64) || \
|
|
|
|
defined(V8_TARGET_ARCH_PPC64)
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_INT(sim_stack_alignment, 16,
|
2014-02-12 09:19:30 +00:00
|
|
|
"Stack alignment in bytes in simulator. This must be a power of two "
|
|
|
|
"and it must be at least 16. 16 is default.")
|
|
|
|
#else
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_INT(sim_stack_alignment, 8,
|
2010-04-15 09:34:47 +00:00
|
|
|
"Stack alingment in bytes in simulator (4 or 8, 8 is default)")
|
2014-02-12 09:19:30 +00:00
|
|
|
#endif
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_INT(sim_stack_size, 2 * MB / KB,
|
2015-06-11 07:07:37 +00:00
|
|
|
"Stack size of the ARM64, MIPS64 and PPC64 simulator "
|
2014-07-09 11:08:26 +00:00
|
|
|
"in kBytes (default is 2 MB)")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(log_regs_modified, true,
|
2014-02-12 09:19:30 +00:00
|
|
|
"When logging register values, only print modified registers.")
|
2016-01-28 18:17:30 +00:00
|
|
|
DEFINE_BOOL(log_colour, ENABLE_LOG_COLOUR,
|
|
|
|
"When logging, try to use coloured output.")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(ignore_asm_unimplemented_break, false,
|
2014-02-12 09:19:30 +00:00
|
|
|
"Don't break for ASM_UNIMPLEMENTED_BREAK macros.")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(trace_sim_messages, false,
|
2014-02-12 09:19:30 +00:00
|
|
|
"Trace simulator debug messages. Implied by --trace-sim.")
|
2008-09-12 10:19:33 +00:00
|
|
|
|
2011-05-13 08:54:16 +00:00
|
|
|
// isolate.cc
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(stack_trace_on_illegal, false,
|
2014-02-11 07:28:05 +00:00
|
|
|
"print stack trace when an illegal exception is thrown")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(abort_on_uncaught_exception, false,
|
2013-04-09 11:31:10 +00:00
|
|
|
"abort program (dump core) when an uncaught exception is thrown")
|
2016-09-29 12:20:02 +00:00
|
|
|
DEFINE_BOOL(abort_on_stack_overflow, false,
|
|
|
|
"Abort program when stack overflow (as opposed to throwing "
|
|
|
|
"RangeError). This is useful for fuzzing where the spec behaviour "
|
|
|
|
"would introduce nondeterminism.")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(randomize_hashes, 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)")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_INT(hash_seed, 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)")
|
2016-05-20 13:36:02 +00:00
|
|
|
DEFINE_BOOL(trace_rail, false, "trace RAIL mode")
|
2016-10-17 08:37:25 +00:00
|
|
|
DEFINE_BOOL(print_all_exceptions, false,
|
|
|
|
"print exception object and stack trace on each thrown exception")
|
2008-09-12 10:19:33 +00:00
|
|
|
|
2016-01-22 10:11:10 +00:00
|
|
|
// runtime.cc
|
|
|
|
DEFINE_BOOL(runtime_call_stats, false, "report runtime call counts and times")
|
2016-10-28 20:43:17 +00:00
|
|
|
DEFINE_INT(runtime_stats, 0,
|
|
|
|
"internal usage only for controlling runtime statistics")
|
|
|
|
DEFINE_VALUE_IMPLICATION(runtime_call_stats, runtime_stats, 1)
|
2016-01-22 10:11:10 +00:00
|
|
|
|
2013-10-02 11:32:19 +00:00
|
|
|
// snapshot-common.cc
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(profile_deserialization, false,
|
2013-10-02 11:32:19 +00:00
|
|
|
"Print the time it takes to deserialize the snapshot.")
|
2015-04-16 13:39:21 +00:00
|
|
|
DEFINE_BOOL(serialization_statistics, false,
|
|
|
|
"Collect statistics on serialized objects.")
|
2013-10-02 11:32:19 +00:00
|
|
|
|
2009-02-25 08:08:01 +00:00
|
|
|
// Regexp
|
2014-07-02 14:00:16 +00:00
|
|
|
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
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(testing_bool_flag, true, "testing_bool_flag")
|
|
|
|
DEFINE_MAYBE_BOOL(testing_maybe_bool_flag, "testing_maybe_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")
|
2008-09-12 10:19:33 +00:00
|
|
|
|
2012-06-19 18:38:03 +00:00
|
|
|
// mksnapshot.cc
|
2015-09-08 15:24:45 +00:00
|
|
|
DEFINE_STRING(startup_src, NULL,
|
|
|
|
"Write V8 startup as C++ src. (mksnapshot only)")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_STRING(startup_blob, NULL,
|
2014-12-10 14:20:12 +00:00
|
|
|
"Write V8 startup blob file. (mksnapshot only)")
|
2012-06-19 18:38:03 +00:00
|
|
|
|
2013-10-02 11:27:37 +00:00
|
|
|
// code-stubs-hydrogen.cc
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(profile_hydrogen_code_stub_compilation, false,
|
2013-10-02 11:27:37 +00:00
|
|
|
"Print the time it takes to lazily compile hydrogen code stubs.")
|
|
|
|
|
2015-02-25 15:40:39 +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)")
|
2013-12-18 17:31:12 +00:00
|
|
|
|
2015-03-27 21:55:27 +00:00
|
|
|
DEFINE_BOOL(manual_evacuation_candidates_selection, false,
|
|
|
|
"Test mode only flag. It allows an unit test to select evacuation "
|
|
|
|
"candidates pages (requires --stress_compaction).")
|
|
|
|
|
2016-01-27 13:21:53 +00:00
|
|
|
DEFINE_BOOL(disable_old_api_accessors, false,
|
|
|
|
"Disable old-style API accessors whose setters trigger through the "
|
|
|
|
"prototype chain")
|
|
|
|
|
2008-10-21 09:12:27 +00:00
|
|
|
//
|
|
|
|
// Dev shell flags
|
|
|
|
//
|
2008-09-12 10:19:33 +00:00
|
|
|
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(help, false, "Print usage message, including flags, on console")
|
|
|
|
DEFINE_BOOL(dump_counters, false, "Dump counters on exit")
|
2011-09-29 08:55:36 +00:00
|
|
|
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_STRING(map_counters, "", "Map counters to a file")
|
|
|
|
DEFINE_ARGS(js_arguments,
|
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-18 16:11:01 +00:00
|
|
|
//
|
|
|
|
// GDB JIT integration flags.
|
|
|
|
//
|
2015-02-25 15:40:39 +00:00
|
|
|
#undef FLAG
|
|
|
|
#ifdef ENABLE_GDB_JIT_INTERFACE
|
|
|
|
#define FLAG FLAG_FULL
|
|
|
|
#else
|
|
|
|
#define FLAG FLAG_READONLY
|
|
|
|
#endif
|
2011-01-18 16:11:01 +00:00
|
|
|
|
2015-02-25 15:40:39 +00:00
|
|
|
DEFINE_BOOL(gdbjit, false, "enable GDBJIT interface")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(gdbjit_full, false, "enable GDBJIT interface for all code objects")
|
|
|
|
DEFINE_BOOL(gdbjit_dump, false, "dump elf objects with debug info to disk")
|
|
|
|
DEFINE_STRING(gdbjit_dump_filter, "",
|
2011-06-30 11:52:00 +00:00
|
|
|
"dump only objects containing this substring")
|
2011-01-18 16:11:01 +00:00
|
|
|
|
2015-02-25 15:40:39 +00:00
|
|
|
#ifdef ENABLE_GDB_JIT_INTERFACE
|
|
|
|
DEFINE_IMPLICATION(gdbjit_full, gdbjit)
|
|
|
|
DEFINE_IMPLICATION(gdbjit_dump, gdbjit)
|
|
|
|
#endif
|
|
|
|
DEFINE_NEG_IMPLICATION(gdbjit, compact_code_space)
|
2011-10-11 15:52:15 +00:00
|
|
|
|
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
|
2014-08-04 11:34:54 +00:00
|
|
|
#ifdef ENABLE_SLOW_DCHECKS
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(enable_slow_asserts, false,
|
2008-09-12 10:19:33 +00:00
|
|
|
"enable asserts that are slow to execute")
|
2013-10-25 11:10:28 +00:00
|
|
|
#endif
|
2008-09-12 10:19:33 +00:00
|
|
|
|
2013-08-26 11:22:39 +00:00
|
|
|
// codegen-ia32.cc / codegen-arm.cc / macro-assembler-*.cc
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(print_ast, false, "print source AST")
|
|
|
|
DEFINE_BOOL(print_builtin_ast, false, "print source AST for builtins")
|
|
|
|
DEFINE_BOOL(trap_on_abort, false, "replace aborts by breakpoints")
|
2008-09-12 10:19:33 +00:00
|
|
|
|
|
|
|
// compiler.cc
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(print_builtin_scopes, false, "print scopes for builtins")
|
|
|
|
DEFINE_BOOL(print_scopes, false, "print scopes")
|
2008-09-12 10:19:33 +00:00
|
|
|
|
|
|
|
// contexts.cc
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(trace_contexts, false, "trace contexts operations")
|
2008-09-12 10:19:33 +00:00
|
|
|
|
|
|
|
// heap.cc
|
2014-07-02 14:00:16 +00:00
|
|
|
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")
|
|
|
|
DEFINE_BOOL(print_handles, false, "report handles after GC")
|
2015-04-01 16:58:32 +00:00
|
|
|
DEFINE_BOOL(check_handle_count, false,
|
|
|
|
"Check that there are not too many handles at GC")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(print_global_handles, false, "report global handles after GC")
|
2008-09-12 10:19:33 +00:00
|
|
|
|
2014-07-30 13:54:45 +00:00
|
|
|
// TurboFan debug-only flags.
|
|
|
|
DEFINE_BOOL(print_turbo_replay, false,
|
|
|
|
"print C++ code to recreate TurboFan graphs")
|
2016-02-04 11:24:09 +00:00
|
|
|
DEFINE_BOOL(trace_turbo_escape, false, "enable tracing in escape analysis")
|
2014-07-30 13:54:45 +00:00
|
|
|
|
2008-09-12 10:19:33 +00:00
|
|
|
// objects.cc
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(trace_normalization, false,
|
2008-09-12 10:19:33 +00:00
|
|
|
"prints when objects are turned into dictionaries.")
|
|
|
|
|
|
|
|
// runtime.cc
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(trace_lazy, false, "trace lazy compilation")
|
2008-09-12 10:19:33 +00:00
|
|
|
|
|
|
|
// spaces.cc
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(collect_heap_spill_statistics, false,
|
2008-09-12 10:19:33 +00:00
|
|
|
"report heap spill statistics along with heap_stats "
|
|
|
|
"(requires heap_stats)")
|
2016-02-11 16:38:58 +00:00
|
|
|
DEFINE_BOOL(trace_live_bytes, false,
|
|
|
|
"trace incrementing and resetting of live bytes")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(trace_isolates, false, "trace isolate state changes")
|
2011-03-18 20:35:07 +00:00
|
|
|
|
2009-02-25 08:08:01 +00:00
|
|
|
// Regexp
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(regexp_possessive_quantifier, false,
|
2010-01-07 19:01:23 +00:00
|
|
|
"enable possessive quantifier syntax for testing")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(trace_regexp_bytecodes, false, "trace regexp bytecode execution")
|
|
|
|
DEFINE_BOOL(trace_regexp_assembler, false,
|
2009-02-25 08:08:01 +00:00
|
|
|
"trace regexp macro assembler calls.")
|
2016-01-11 14:18:29 +00:00
|
|
|
DEFINE_BOOL(trace_regexp_parser, false, "trace regexp parsing")
|
2008-11-27 13:54:31 +00:00
|
|
|
|
2016-02-25 11:59:11 +00:00
|
|
|
// Debugger
|
|
|
|
DEFINE_BOOL(print_break_location, false, "print source location on debug break")
|
|
|
|
|
2016-10-04 22:21:23 +00:00
|
|
|
// wasm instance management
|
|
|
|
DEFINE_BOOL(trace_wasm_instances, false,
|
|
|
|
"trace creation and collection of wasm instances")
|
|
|
|
|
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
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(log, false,
|
2008-09-12 10:19:33 +00:00
|
|
|
"Minimal logging (no API, code, GC, suspect, or handles samples).")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(log_all, false, "Log all events to the log file.")
|
|
|
|
DEFINE_BOOL(log_api, false, "Log API events to the log file.")
|
|
|
|
DEFINE_BOOL(log_code, false,
|
2008-09-12 10:19:33 +00:00
|
|
|
"Log code events to the log file without profiling.")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(log_gc, false,
|
2008-09-12 10:19:33 +00:00
|
|
|
"Log heap samples on garbage collection for the hp2ps tool.")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(log_handles, false, "Log global handle events.")
|
|
|
|
DEFINE_BOOL(log_suspect, false, "Log suspect operations.")
|
|
|
|
DEFINE_BOOL(prof, false,
|
2008-09-12 10:19:33 +00:00
|
|
|
"Log statistical profiling information (implies --log-code).")
|
2015-01-20 16:06:03 +00:00
|
|
|
DEFINE_BOOL(prof_cpp, false, "Like --prof, but ignore generated code.")
|
|
|
|
DEFINE_IMPLICATION(prof, prof_cpp)
|
2014-07-02 14:00:16 +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.")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_STRING(logfile, "v8.log", "Specify the name of the log file.")
|
|
|
|
DEFINE_BOOL(logfile_per_isolate, true, "Separate log files for each isolate.")
|
|
|
|
DEFINE_BOOL(ll_prof, false, "Enable low-level linux profiler.")
|
|
|
|
DEFINE_BOOL(perf_basic_prof, false,
|
2013-11-25 06:44:23 +00:00
|
|
|
"Enable perf linux profiler (basic support).")
|
2014-07-03 19:18:26 +00:00
|
|
|
DEFINE_NEG_IMPLICATION(perf_basic_prof, compact_code_space)
|
2015-08-14 14:51:51 +00:00
|
|
|
DEFINE_BOOL(perf_basic_prof_only_functions, false,
|
|
|
|
"Only report function code ranges to perf (i.e. no stubs).")
|
|
|
|
DEFINE_IMPLICATION(perf_basic_prof_only_functions, perf_basic_prof)
|
2016-03-29 06:23:56 +00:00
|
|
|
DEFINE_BOOL(perf_prof, false,
|
|
|
|
"Enable perf linux profiler (experimental annotate support).")
|
|
|
|
DEFINE_NEG_IMPLICATION(perf_prof, compact_code_space)
|
|
|
|
DEFINE_BOOL(perf_prof_debug_info, false,
|
|
|
|
"Enable debug info for perf linux profiler (experimental).")
|
2016-06-27 15:06:32 +00:00
|
|
|
DEFINE_BOOL(perf_prof_unwinding_info, false,
|
|
|
|
"Enable unwinding info for perf linux profiler (experimental).")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_STRING(gc_fake_mmap, "/tmp/__v8_gc__",
|
2012-09-06 15:01:20 +00:00
|
|
|
"Specify the name of the file for fake gc mmap used in ll_prof")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(log_internal_timer_events, false, "Time internal events.")
|
|
|
|
DEFINE_BOOL(log_timer_events, false,
|
2012-12-05 16:22:14 +00:00
|
|
|
"Time events including external callbacks.")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_IMPLICATION(log_timer_events, log_internal_timer_events)
|
|
|
|
DEFINE_IMPLICATION(log_internal_timer_events, prof)
|
|
|
|
DEFINE_BOOL(log_instruction_stats, false, "Log AArch64 instruction statistics.")
|
|
|
|
DEFINE_STRING(log_instruction_file, "arm64_inst.csv",
|
2014-02-12 09:19:30 +00:00
|
|
|
"AArch64 instruction statistics log file.")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_INT(log_instruction_period, 1 << 22,
|
2014-02-12 09:19:30 +00:00
|
|
|
"AArch64 instruction statistics logging period.")
|
2012-06-19 18:38:03 +00:00
|
|
|
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(redirect_code_traces, false,
|
2013-11-07 16:35:27 +00:00
|
|
|
"output deopt information and disassembly into file "
|
|
|
|
"code-<pid>-<isolate id>.asm")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_STRING(redirect_code_traces_to, NULL,
|
|
|
|
"output deopt information and disassembly into the given file")
|
2013-11-07 16:35:27 +00:00
|
|
|
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(hydrogen_track_positions, false,
|
2014-02-13 16:09:28 +00:00
|
|
|
"track source code positions when building IR")
|
|
|
|
|
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
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(trace_elements_transitions, false, "trace elements transitions")
|
2011-10-20 09:38:24 +00:00
|
|
|
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(trace_creation_allocation_sites, false,
|
2013-10-16 08:10:36 +00:00
|
|
|
"trace the creation of allocation sites")
|
|
|
|
|
2009-03-04 06:14:34 +00:00
|
|
|
// code-stubs.cc
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(print_code_stubs, false, "print code stubs")
|
|
|
|
DEFINE_BOOL(test_secondary_stub_cache, false,
|
2012-02-29 10:45:59 +00:00
|
|
|
"test secondary stub cache by disabling the primary one")
|
|
|
|
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(test_primary_stub_cache, false,
|
2012-02-29 10:45:59 +00:00
|
|
|
"test primary stub cache by disabling the secondary one")
|
2009-03-04 06:14:34 +00:00
|
|
|
|
2013-10-02 11:27:37 +00:00
|
|
|
|
2008-09-12 10:19:33 +00:00
|
|
|
// codegen-ia32.cc / codegen-arm.cc
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(print_code, false, "print generated code")
|
|
|
|
DEFINE_BOOL(print_opt_code, false, "print optimized code")
|
2016-09-28 17:03:29 +00:00
|
|
|
DEFINE_STRING(print_opt_code_filter, "*", "filter for printing optimized code")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(print_unopt_code, false,
|
|
|
|
"print unoptimized code before "
|
2010-12-17 14:16:00 +00:00
|
|
|
"printing optimized code based on it")
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(print_code_verbose, false, "print more information for code")
|
|
|
|
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
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(sodium, false,
|
|
|
|
"print generated code output suitable for use with "
|
2013-10-21 13:35:48 +00:00
|
|
|
"the Sodium code viewer")
|
|
|
|
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_IMPLICATION(sodium, print_code_stubs)
|
|
|
|
DEFINE_IMPLICATION(sodium, print_code)
|
|
|
|
DEFINE_IMPLICATION(sodium, print_opt_code)
|
|
|
|
DEFINE_IMPLICATION(sodium, hydrogen_track_positions)
|
|
|
|
DEFINE_IMPLICATION(sodium, code_comments)
|
|
|
|
|
|
|
|
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)
|
|
|
|
DEFINE_IMPLICATION(print_all_code, code_comments)
|
2011-12-21 16:19:55 +00:00
|
|
|
#ifdef DEBUG
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_IMPLICATION(print_all_code, trace_codegen)
|
2011-12-21 16:19:55 +00:00
|
|
|
#endif
|
2011-12-15 17:00:27 +00:00
|
|
|
#endif
|
|
|
|
|
2016-10-21 11:47:25 +00:00
|
|
|
#undef FLAG
|
|
|
|
#define FLAG FLAG_FULL
|
2014-06-20 07:35:48 +00:00
|
|
|
|
2016-10-28 12:50:20 +00:00
|
|
|
//
|
|
|
|
// Predictable mode related flags.
|
|
|
|
//
|
|
|
|
|
|
|
|
DEFINE_BOOL(predictable, false, "enable predictable mode")
|
|
|
|
DEFINE_IMPLICATION(predictable, single_threaded)
|
|
|
|
DEFINE_NEG_IMPLICATION(predictable, memory_reducer)
|
|
|
|
|
2014-06-20 07:35:48 +00:00
|
|
|
//
|
2016-10-21 11:47:25 +00:00
|
|
|
// Threading related flags.
|
|
|
|
//
|
|
|
|
|
|
|
|
DEFINE_BOOL(single_threaded, false, "disable the use of background tasks")
|
|
|
|
DEFINE_NEG_IMPLICATION(single_threaded, concurrent_recompilation)
|
|
|
|
DEFINE_NEG_IMPLICATION(single_threaded, concurrent_sweeping)
|
|
|
|
DEFINE_NEG_IMPLICATION(single_threaded, parallel_compaction)
|
|
|
|
|
|
|
|
|
2014-06-20 07:35:48 +00:00
|
|
|
#undef FLAG
|
|
|
|
|
|
|
|
#ifdef VERIFY_PREDICTABLE
|
|
|
|
#define FLAG FLAG_FULL
|
|
|
|
#else
|
|
|
|
#define FLAG FLAG_READONLY
|
|
|
|
#endif
|
|
|
|
|
2014-07-02 14:00:16 +00:00
|
|
|
DEFINE_BOOL(verify_predictable, false,
|
2014-06-20 07:35:48 +00:00
|
|
|
"this mode is used for checking that V8 behaves predictably")
|
2015-11-12 13:42:49 +00:00
|
|
|
DEFINE_INT(dump_allocations_digest_at_alloc, -1,
|
2014-07-02 14:00:16 +00:00
|
|
|
"dump allocations digest each n-th allocation")
|
2014-06-20 07:35:48 +00:00
|
|
|
|
2013-09-23 15:01:33 +00:00
|
|
|
//
|
|
|
|
// Read-only flags
|
|
|
|
//
|
|
|
|
#undef FLAG
|
|
|
|
#define FLAG FLAG_READONLY
|
|
|
|
|
2014-10-13 14:41:33 +00:00
|
|
|
// assembler.h
|
2015-06-04 14:44:00 +00:00
|
|
|
DEFINE_BOOL(enable_embedded_constant_pool, V8_EMBEDDED_CONSTANT_POOL,
|
|
|
|
"enable use of embedded constant pools (ARM/PPC only)")
|
2013-09-23 15:01:33 +00:00
|
|
|
|
2014-11-11 10:24:52 +00:00
|
|
|
DEFINE_BOOL(unbox_double_fields, V8_DOUBLE_FIELDS_UNBOXING,
|
|
|
|
"enable in-object double fields unboxing (64-bit only)")
|
|
|
|
DEFINE_IMPLICATION(unbox_double_fields, track_double_fields)
|
|
|
|
|
2008-09-12 10:19:33 +00:00
|
|
|
// Cleanup...
|
|
|
|
#undef FLAG_FULL
|
|
|
|
#undef FLAG_READONLY
|
|
|
|
#undef FLAG
|
2013-08-22 16:14:37 +00:00
|
|
|
#undef FLAG_ALIAS
|
2008-09-12 10:19:33 +00:00
|
|
|
|
2014-07-02 14:00:16 +00:00
|
|
|
#undef DEFINE_BOOL
|
|
|
|
#undef DEFINE_MAYBE_BOOL
|
|
|
|
#undef DEFINE_INT
|
|
|
|
#undef DEFINE_STRING
|
|
|
|
#undef DEFINE_FLOAT
|
|
|
|
#undef DEFINE_ARGS
|
|
|
|
#undef DEFINE_IMPLICATION
|
|
|
|
#undef DEFINE_NEG_IMPLICATION
|
2014-12-05 15:35:32 +00:00
|
|
|
#undef DEFINE_NEG_VALUE_IMPLICATION
|
2014-09-19 09:15:47 +00:00
|
|
|
#undef DEFINE_VALUE_IMPLICATION
|
2014-07-02 14:00:16 +00:00
|
|
|
#undef DEFINE_ALIAS_BOOL
|
|
|
|
#undef DEFINE_ALIAS_INT
|
|
|
|
#undef DEFINE_ALIAS_STRING
|
|
|
|
#undef DEFINE_ALIAS_FLOAT
|
|
|
|
#undef DEFINE_ALIAS_ARGS
|
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
|
2013-09-17 13:48:17 +00:00
|
|
|
|
|
|
|
#undef COMMA
|