// Copyright 2012 the V8 project authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. // 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: // // PRESUBMIT_INTENTIONALLY_MISSING_INCLUDE_GUARD #define DEFINE_IMPLICATION(whenflag, thenflag) \ DEFINE_VALUE_IMPLICATION(whenflag, thenflag, true) // A weak implication will be overwritten by a normal implication or by an // explicit flag. #define DEFINE_WEAK_IMPLICATION(whenflag, thenflag) \ DEFINE_WEAK_VALUE_IMPLICATION(whenflag, thenflag, true) #define DEFINE_WEAK_NEG_IMPLICATION(whenflag, thenflag) \ DEFINE_WEAK_VALUE_IMPLICATION(whenflag, thenflag, false) #define DEFINE_NEG_IMPLICATION(whenflag, thenflag) \ DEFINE_VALUE_IMPLICATION(whenflag, thenflag, false) #define DEFINE_NEG_NEG_IMPLICATION(whenflag, thenflag) \ DEFINE_NEG_VALUE_IMPLICATION(whenflag, thenflag, false) // With FLAG_MODE_DECLARE we declare the fields in the {FlagValues} struct. // Read-only flags are static constants instead of fields. #if defined(FLAG_MODE_DECLARE) #define FLAG_FULL(ftype, ctype, nam, def, cmt) FlagValue<ctype> nam{ … } #define FLAG_READONLY(ftype, ctype, nam, def, cmt) \ static constexpr FlagValue<ctype> nam{ … } // 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 constexpr ctype FLAGDEFAULT_##nam{ … } #define FLAG_READONLY(ftype, ctype, nam, def, cmt) \ static constexpr ctype FLAGDEFAULT_##nam{ … } // We want to write entries into our meta data table, for internal parsing and // printing / etc in the flag parser code. #elif defined(FLAG_MODE_META) #define FLAG_FULL(ftype, ctype, nam, def, cmt) \ { … } // Readonly flags don't pass the value pointer since the struct expects a // mutable value. That's okay since the value always equals the default. #define FLAG_READONLY(ftype, ctype, nam, def, cmt) \ { … } #define FLAG_ALIAS(ftype, ctype, alias, nam) \ { … } // We produce the code to set flags when it is implied by another flag. #elif defined(FLAG_MODE_DEFINE_IMPLICATIONS) #define DEFINE_VALUE_IMPLICATION(whenflag, thenflag, value) \ changed |= TriggerImplication(v8_flags.whenflag, #whenflag, \ &v8_flags.thenflag, #thenflag, value, false); // A weak implication will be overwritten by a normal implication or by an // explicit flag. #define DEFINE_WEAK_VALUE_IMPLICATION(whenflag, thenflag, value) \ changed |= TriggerImplication(v8_flags.whenflag, #whenflag, \ &v8_flags.thenflag, #thenflag, value, true); #define DEFINE_GENERIC_IMPLICATION(whenflag, statement) \ if (v8_flags.whenflag) statement; #define DEFINE_NEG_VALUE_IMPLICATION(whenflag, thenflag, value) \ changed |= TriggerImplication(!v8_flags.whenflag, "!" #whenflag, \ &v8_flags.thenflag, #thenflag, value, false); #define DEFINE_NEG_VALUE_VALUE_IMPLICATION(whenflag, whenvalue, thenflag, \ thenvalue) \ changed |= \ TriggerImplication(v8_flags.whenflag != whenvalue, #whenflag, \ &v8_flags.thenflag, #thenflag, thenvalue, false); #define DEFINE_MIN_VALUE_IMPLICATION(flag, min_value) \ changed |= TriggerImplication(v8_flags.flag < min_value, #flag, \ &v8_flags.flag, #flag, min_value, false); #define DEFINE_DISABLE_FLAG_IMPLICATION(whenflag, thenflag) \ if (v8_flags.whenflag && v8_flags.thenflag) { … } // We apply a generic macro to the flags. #elif defined(FLAG_MODE_APPLY) #define FLAG_FULL FLAG_MODE_APPLY #else #error No mode supplied when including flags.defs #endif // 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 #ifndef DEFINE_VALUE_IMPLICATION #define DEFINE_VALUE_IMPLICATION(whenflag, thenflag, value) #endif #ifndef DEFINE_WEAK_VALUE_IMPLICATION #define DEFINE_WEAK_VALUE_IMPLICATION(whenflag, thenflag, value) #endif #ifndef DEFINE_GENERIC_IMPLICATION #define DEFINE_GENERIC_IMPLICATION(whenflag, statement) #endif #ifndef DEFINE_NEG_VALUE_IMPLICATION #define DEFINE_NEG_VALUE_IMPLICATION(whenflag, thenflag, value) #endif #ifndef DEFINE_NEG_VALUE_VALUE_IMPLICATION #define DEFINE_NEG_VALUE_VALUE_IMPLICATION(whenflag, whenvalue, thenflag, \ thenvalue) #endif #ifndef DEFINE_MIN_VALUE_IMPLICATION #define DEFINE_MIN_VALUE_IMPLICATION(flag, min_value) #endif #ifndef DEFINE_DISABLE_FLAG_IMPLICATION #define DEFINE_DISABLE_FLAG_IMPLICATION(whenflag, thenflag) #endif #ifndef DEBUG_BOOL #error DEBUG_BOOL must be defined at this point. #endif // DEBUG_BOOL #if V8_ENABLE_SPARKPLUG #define ENABLE_SPARKPLUG_BY_DEFAULT true #else #define ENABLE_SPARKPLUG_BY_DEFAULT false #endif // 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" #else #define ARM_ARCH_DEFAULT "armv6" #endif #ifdef V8_OS_WIN #define ENABLE_LOG_COLOUR false #else #define ENABLE_LOG_COLOUR true #endif #define DEFINE_BOOL(nam, def, cmt) FLAG(BOOL, bool, nam, def, cmt) #define DEFINE_BOOL_READONLY(nam, def, cmt) \ FLAG_READONLY(BOOL, bool, nam, def, cmt) #define DEFINE_MAYBE_BOOL(nam, cmt) \ FLAG(MAYBE_BOOL, std::optional<bool>, nam, std::nullopt, cmt) #define DEFINE_INT(nam, def, cmt) FLAG(INT, int, nam, def, cmt) #define DEFINE_UINT(nam, def, cmt) FLAG(UINT, unsigned int, nam, def, cmt) #define DEFINE_UINT_READONLY(nam, def, cmt) \ FLAG_READONLY(UINT, unsigned int, nam, def, cmt) #define DEFINE_UINT64(nam, def, cmt) FLAG(UINT64, uint64_t, nam, def, cmt) #define DEFINE_FLOAT(nam, def, cmt) FLAG(FLOAT, double, nam, def, cmt) #define DEFINE_SIZE_T(nam, def, cmt) FLAG(SIZE_T, size_t, nam, def, cmt) #define DEFINE_STRING(nam, def, cmt) FLAG(STRING, const char*, nam, def, 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_SIZE_T(alias, nam) FLAG_ALIAS(SIZE_T, size_t, alias, nam) #define DEFINE_ALIAS_STRING(alias, nam) \ FLAG_ALIAS(STRING, const char*, alias, nam) #ifdef DEBUG #define DEFINE_DEBUG_BOOL DEFINE_BOOL #else #define DEFINE_DEBUG_BOOL DEFINE_BOOL_READONLY #endif // // Flags in all modes. // #define FLAG FLAG_FULL // Experimental features. // Features that are still considered experimental and which are not ready for // fuzz testing should be defined using this macro. The feature will then imply // --experimental, which will indicate to the user that they are running an // experimental configuration of V8. Experimental features are always disabled // by default. When these features mature, the flag should first turn into a // regular feature flag (still disabled by default) and then ideally be staged // behind (for example) --future before being enabled by default. DEFINE_BOOL( … }
Codebase Browser
chromium