LCOV - code coverage report
Current view: top level - src - flag-definitions.h (source / functions) Hit Total Coverage
Test: app.info Lines: 497 497 100.0 %
Date: 2019-03-21 Functions: 0 0 -

          Line data    Source code
       1             : // Copyright 2012 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : // This file defines all of the flags.  It is separated into different section,
       6             : // for Debug, Release, Logging and Profiling, etc.  To add a new flag, find the
       7             : // correct section, and use one of the DEFINE_ macros, without a trailing ';'.
       8             : //
       9             : // This include does not have a guard, because it is a template-style include,
      10             : // which can be included multiple times in different modes.  It expects to have
      11             : // a mode defined before it's included.  The modes are FLAG_MODE_... below:
      12             : //
      13             : // PRESUBMIT_INTENTIONALLY_MISSING_INCLUDE_GUARD
      14             : 
      15             : #define DEFINE_IMPLICATION(whenflag, thenflag)              \
      16             :   DEFINE_VALUE_IMPLICATION(whenflag, thenflag, true)
      17             : 
      18             : #define DEFINE_NEG_IMPLICATION(whenflag, thenflag)          \
      19             :   DEFINE_VALUE_IMPLICATION(whenflag, thenflag, false)
      20             : 
      21             : #define DEFINE_NEG_NEG_IMPLICATION(whenflag, thenflag) \
      22             :   DEFINE_NEG_VALUE_IMPLICATION(whenflag, thenflag, false)
      23             : 
      24             : // We want to declare the names of the variables for the header file.  Normally
      25             : // this will just be an extern declaration, but for a readonly flag we let the
      26             : // compiler make better optimizations by giving it the value.
      27             : #if defined(FLAG_MODE_DECLARE)
      28             : #define FLAG_FULL(ftype, ctype, nam, def, cmt) \
      29             :   V8_EXPORT_PRIVATE extern ctype FLAG_##nam;
      30             : #define FLAG_READONLY(ftype, ctype, nam, def, cmt) \
      31             :   static constexpr ctype FLAG_##nam = def;
      32             : 
      33             : // We want to supply the actual storage and value for the flag variable in the
      34             : // .cc file.  We only do this for writable flags.
      35             : #elif defined(FLAG_MODE_DEFINE)
      36             : #ifdef USING_V8_SHARED
      37             : #define FLAG_FULL(ftype, ctype, nam, def, cmt) \
      38             :   V8_EXPORT_PRIVATE extern ctype FLAG_##nam;
      39             : #else
      40             : #define FLAG_FULL(ftype, ctype, nam, def, cmt) \
      41             :   V8_EXPORT_PRIVATE ctype FLAG_##nam = def;
      42             : #endif
      43             : 
      44             : // We need to define all of our default values so that the Flag structure can
      45             : // access them by pointer.  These are just used internally inside of one .cc,
      46             : // for MODE_META, so there is no impact on the flags interface.
      47             : #elif defined(FLAG_MODE_DEFINE_DEFAULTS)
      48             : #define FLAG_FULL(ftype, ctype, nam, def, cmt) \
      49             :   static constexpr ctype FLAGDEFAULT_##nam = def;
      50             : 
      51             : // We want to write entries into our meta data table, for internal parsing and
      52             : // printing / etc in the flag parser code.  We only do this for writable flags.
      53             : #elif defined(FLAG_MODE_META)
      54             : #define FLAG_FULL(ftype, ctype, nam, def, cmt)                              \
      55             :   { Flag::TYPE_##ftype, #nam, &FLAG_##nam, &FLAGDEFAULT_##nam, cmt, false } \
      56             :   ,
      57             : #define FLAG_ALIAS(ftype, ctype, alias, nam)                     \
      58             :   {                                                              \
      59             :     Flag::TYPE_##ftype, #alias, &FLAG_##nam, &FLAGDEFAULT_##nam, \
      60             :         "alias for --" #nam, false                               \
      61             :   }                                                              \
      62             :   ,
      63             : 
      64             : // We produce the code to set flags when it is implied by another flag.
      65             : #elif defined(FLAG_MODE_DEFINE_IMPLICATIONS)
      66             : #define DEFINE_VALUE_IMPLICATION(whenflag, thenflag, value) \
      67             :   if (FLAG_##whenflag) FLAG_##thenflag = value;
      68             : 
      69             : #define DEFINE_GENERIC_IMPLICATION(whenflag, statement) \
      70             :   if (FLAG_##whenflag) statement;
      71             : 
      72             : #define DEFINE_NEG_VALUE_IMPLICATION(whenflag, thenflag, value) \
      73             :   if (!FLAG_##whenflag) FLAG_##thenflag = value;
      74             : 
      75             : // We apply a generic macro to the flags.
      76             : #elif defined(FLAG_MODE_APPLY)
      77             : 
      78             : #define FLAG_FULL FLAG_MODE_APPLY
      79             : 
      80             : #else
      81             : #error No mode supplied when including flags.defs
      82             : #endif
      83             : 
      84             : // Dummy defines for modes where it is not relevant.
      85             : #ifndef FLAG_FULL
      86             : #define FLAG_FULL(ftype, ctype, nam, def, cmt)
      87             : #endif
      88             : 
      89             : #ifndef FLAG_READONLY
      90             : #define FLAG_READONLY(ftype, ctype, nam, def, cmt)
      91             : #endif
      92             : 
      93             : #ifndef FLAG_ALIAS
      94             : #define FLAG_ALIAS(ftype, ctype, alias, nam)
      95             : #endif
      96             : 
      97             : #ifndef DEFINE_VALUE_IMPLICATION
      98             : #define DEFINE_VALUE_IMPLICATION(whenflag, thenflag, value)
      99             : #endif
     100             : 
     101             : #ifndef DEFINE_GENERIC_IMPLICATION
     102             : #define DEFINE_GENERIC_IMPLICATION(whenflag, statement)
     103             : #endif
     104             : 
     105             : #ifndef DEFINE_NEG_VALUE_IMPLICATION
     106             : #define DEFINE_NEG_VALUE_IMPLICATION(whenflag, thenflag, value)
     107             : #endif
     108             : 
     109             : #define COMMA ,
     110             : 
     111             : #ifdef FLAG_MODE_DECLARE
     112             : 
     113             : struct MaybeBoolFlag {
     114             :   static MaybeBoolFlag Create(bool has_value, bool value) {
     115             :     MaybeBoolFlag flag;
     116             :     flag.has_value = has_value;
     117          25 :     flag.value = value;
     118             :     return flag;
     119             :   }
     120             :   bool has_value;
     121             :   bool value;
     122             : 
     123             :   bool operator!=(const MaybeBoolFlag& other) const {
     124         294 :     return has_value != other.has_value || value != other.value;
     125             :   }
     126             : };
     127             : #endif
     128             : 
     129             : #ifdef DEBUG
     130             : #define DEBUG_BOOL true
     131             : #else
     132             : #define DEBUG_BOOL false
     133             : #endif
     134             : 
     135             : #ifdef V8_COMPRESS_POINTERS
     136             : #define COMPRESS_POINTERS_BOOL true
     137             : #else
     138             : #define COMPRESS_POINTERS_BOOL false
     139             : #endif
     140             : 
     141             : // Supported ARM configurations are:
     142             : //  "armv6":       ARMv6 + VFPv2
     143             : //  "armv7":       ARMv7 + VFPv3-D32 + NEON
     144             : //  "armv7+sudiv": ARMv7 + VFPv4-D32 + NEON + SUDIV
     145             : //  "armv8":       ARMv8 (including all of the above)
     146             : #if !defined(ARM_TEST_NO_FEATURE_PROBE) ||                            \
     147             :     (defined(CAN_USE_ARMV8_INSTRUCTIONS) &&                           \
     148             :      defined(CAN_USE_ARMV7_INSTRUCTIONS) && defined(CAN_USE_SUDIV) && \
     149             :      defined(CAN_USE_NEON) && defined(CAN_USE_VFP3_INSTRUCTIONS))
     150             : #define ARM_ARCH_DEFAULT "armv8"
     151             : #elif defined(CAN_USE_ARMV7_INSTRUCTIONS) && defined(CAN_USE_SUDIV) && \
     152             :     defined(CAN_USE_NEON) && defined(CAN_USE_VFP3_INSTRUCTIONS)
     153             : #define ARM_ARCH_DEFAULT "armv7+sudiv"
     154             : #elif defined(CAN_USE_ARMV7_INSTRUCTIONS) && defined(CAN_USE_NEON) && \
     155             :     defined(CAN_USE_VFP3_INSTRUCTIONS)
     156             : #define ARM_ARCH_DEFAULT "armv7"
     157             : #else
     158             : #define ARM_ARCH_DEFAULT "armv6"
     159             : #endif
     160             : 
     161             : #ifdef V8_OS_WIN
     162             : # define ENABLE_LOG_COLOUR false
     163             : #else
     164             : # define ENABLE_LOG_COLOUR true
     165             : #endif
     166             : 
     167             : #define DEFINE_BOOL(nam, def, cmt) FLAG(BOOL, bool, nam, def, cmt)
     168             : #define DEFINE_BOOL_READONLY(nam, def, cmt) \
     169             :   FLAG_READONLY(BOOL, bool, nam, def, cmt)
     170             : #define DEFINE_MAYBE_BOOL(nam, cmt) \
     171             :   FLAG(MAYBE_BOOL, MaybeBoolFlag, nam, {false COMMA false}, cmt)
     172             : #define DEFINE_INT(nam, def, cmt) FLAG(INT, int, nam, def, cmt)
     173             : #define DEFINE_UINT(nam, def, cmt) FLAG(UINT, unsigned int, nam, def, cmt)
     174             : #define DEFINE_UINT64(nam, def, cmt) FLAG(UINT64, uint64_t, nam, def, cmt)
     175             : #define DEFINE_FLOAT(nam, def, cmt) FLAG(FLOAT, double, nam, def, cmt)
     176             : #define DEFINE_SIZE_T(nam, def, cmt) FLAG(SIZE_T, size_t, nam, def, cmt)
     177             : #define DEFINE_STRING(nam, def, cmt) FLAG(STRING, const char*, nam, def, cmt)
     178             : #define DEFINE_ALIAS_BOOL(alias, nam) FLAG_ALIAS(BOOL, bool, alias, nam)
     179             : #define DEFINE_ALIAS_INT(alias, nam) FLAG_ALIAS(INT, int, alias, nam)
     180             : #define DEFINE_ALIAS_FLOAT(alias, nam) FLAG_ALIAS(FLOAT, double, alias, nam)
     181             : #define DEFINE_ALIAS_SIZE_T(alias, nam) FLAG_ALIAS(SIZE_T, size_t, alias, nam)
     182             : #define DEFINE_ALIAS_STRING(alias, nam) \
     183             :   FLAG_ALIAS(STRING, const char*, alias, nam)
     184             : 
     185             : #ifdef DEBUG
     186             : #define DEFINE_DEBUG_BOOL DEFINE_BOOL
     187             : #else
     188             : #define DEFINE_DEBUG_BOOL DEFINE_BOOL_READONLY
     189             : #endif
     190             : 
     191             : //
     192             : // Flags in all modes.
     193             : //
     194             : #define FLAG FLAG_FULL
     195             : 
     196             : // Flags for language modes and experimental language features.
     197          84 : DEFINE_BOOL(use_strict, false, "enforce strict mode")
     198             : 
     199          84 : DEFINE_BOOL(es_staging, false,
     200             :             "enable test-worthy harmony features (for internal use only)")
     201          84 : DEFINE_BOOL(harmony, false, "enable all completed harmony features")
     202          84 : DEFINE_BOOL(harmony_shipping, true, "enable all shipped harmony features")
     203      171179 : DEFINE_IMPLICATION(es_staging, harmony)
     204             : // Enabling import.meta requires to also enable import()
     205      171179 : DEFINE_IMPLICATION(harmony_import_meta, harmony_dynamic_import)
     206             : 
     207      171179 : DEFINE_IMPLICATION(harmony_class_fields, harmony_public_fields)
     208      171179 : DEFINE_IMPLICATION(harmony_class_fields, harmony_static_fields)
     209      171179 : DEFINE_IMPLICATION(harmony_class_fields, harmony_private_fields)
     210             : 
     211      171179 : DEFINE_IMPLICATION(harmony_private_methods, harmony_private_fields)
     212             : 
     213             : // Update bootstrapper.cc whenever adding a new feature flag.
     214             : 
     215             : // Features that are still work in progress (behind individual flags).
     216             : #define HARMONY_INPROGRESS_BASE(V)                                        \
     217             :   V(harmony_class_fields, "harmony fields in class literals")             \
     218             :   V(harmony_private_methods, "harmony private methods in class literals") \
     219             :   V(harmony_regexp_sequence, "RegExp Unicode sequence properties")        \
     220             :   V(harmony_weak_refs, "harmony weak references")                         \
     221             : 
     222             : #ifdef V8_INTL_SUPPORT
     223             : #define HARMONY_INPROGRESS(V)                               \
     224             :   HARMONY_INPROGRESS_BASE(V)                                \
     225             :   V(harmony_intl_bigint, "BigInt.prototype.toLocaleString") \
     226             :   V(harmony_intl_datetime_style, "dateStyle timeStyle for DateTimeFormat")
     227             : #else
     228             : #define HARMONY_INPROGRESS(V) HARMONY_INPROGRESS_BASE(V)
     229             : #endif
     230             : 
     231             : // Features that are complete (but still behind --harmony/es-staging flag).
     232             : #define HARMONY_STAGED_BASE(V) \
     233             :   V(harmony_numeric_separator, "harmony numeric separator between digits")
     234             : 
     235             : #ifdef V8_INTL_SUPPORT
     236             : #define HARMONY_STAGED(V)          \
     237             :   HARMONY_STAGED_BASE(V)           \
     238             :   V(harmony_intl_segmenter, "Intl.Segmenter")
     239             : #else
     240             : #define HARMONY_STAGED(V) HARMONY_STAGED_BASE(V)
     241             : #endif
     242             : 
     243             : // Features that are shipping (turned on by default, but internal flag remains).
     244             : #define HARMONY_SHIPPING_BASE(V)                                               \
     245             :   V(harmony_namespace_exports,                                                 \
     246             :     "harmony namespace exports (export * as foo from 'bar')")                  \
     247             :   V(harmony_sharedarraybuffer, "harmony sharedarraybuffer")                    \
     248             :   V(harmony_import_meta, "harmony import.meta property")                       \
     249             :   V(harmony_dynamic_import, "harmony dynamic import")                          \
     250             :   V(harmony_global, "harmony global")                                          \
     251             :   V(harmony_json_stringify, "well-formed JSON.stringify")                      \
     252             :   V(harmony_public_fields, "harmony public instance fields in class literals") \
     253             :   V(harmony_static_fields, "harmony static fields in class literals")          \
     254             :   V(harmony_string_matchall, "harmony String.prototype.matchAll")              \
     255             :   V(harmony_object_from_entries, "harmony Object.fromEntries()")               \
     256             :   V(harmony_await_optimization, "harmony await taking 1 tick")                 \
     257             :   V(harmony_private_fields, "harmony private fields in class literals")        \
     258             :   V(harmony_hashbang, "harmony hashbang syntax")
     259             : 
     260             : #ifdef V8_INTL_SUPPORT
     261             : #define HARMONY_SHIPPING(V) \
     262             :   HARMONY_SHIPPING_BASE(V)  \
     263             :   V(harmony_locale, "Intl.Locale")
     264             : #else
     265             : #define HARMONY_SHIPPING(V) HARMONY_SHIPPING_BASE(V)
     266             : #endif
     267             : 
     268             : // Once a shipping feature has proved stable in the wild, it will be dropped
     269             : // from HARMONY_SHIPPING, all occurrences of the FLAG_ variable are removed,
     270             : // and associated tests are moved from the harmony directory to the appropriate
     271             : // esN directory.
     272             : 
     273             : 
     274             : #define FLAG_INPROGRESS_FEATURES(id, description) \
     275             :   DEFINE_BOOL(id, false, "enable " #description " (in progress)")
     276          84 : HARMONY_INPROGRESS(FLAG_INPROGRESS_FEATURES)
     277             : #undef FLAG_INPROGRESS_FEATURES
     278             : 
     279             : #define FLAG_STAGED_FEATURES(id, description) \
     280             :   DEFINE_BOOL(id, false, "enable " #description) \
     281             :   DEFINE_IMPLICATION(harmony, id)
     282      171263 : HARMONY_STAGED(FLAG_STAGED_FEATURES)
     283             : #undef FLAG_STAGED_FEATURES
     284             : 
     285             : #define FLAG_SHIPPING_FEATURES(id, description) \
     286             :   DEFINE_BOOL(id, true, "enable " #description) \
     287             :   DEFINE_NEG_NEG_IMPLICATION(harmony_shipping, id)
     288      171263 : HARMONY_SHIPPING(FLAG_SHIPPING_FEATURES)
     289             : #undef FLAG_SHIPPING_FEATURES
     290             : 
     291             : #ifdef V8_INTL_SUPPORT
     292          84 : DEFINE_BOOL(icu_timezone_data, true, "get information about timezones from ICU")
     293             : #endif
     294             : 
     295             : #ifdef V8_ENABLE_RAW_HEAP_SNAPSHOTS
     296             : #define V8_ENABLE_RAW_HEAP_SNAPSHOTS_BOOL true
     297             : #else
     298             : #define V8_ENABLE_RAW_HEAP_SNAPSHOTS_BOOL false
     299             : #endif  // V8_ENABLE_RAW_HEAP_SNAPSHOTS
     300             : 
     301             : #ifdef V8_LITE_MODE
     302             : #define V8_LITE_BOOL true
     303             : #else
     304             : #define V8_LITE_BOOL false
     305             : #endif
     306             : 
     307             : #ifdef V8_ENABLE_FUTURE
     308             : #define FUTURE_BOOL true
     309             : #else
     310             : #define FUTURE_BOOL false
     311             : #endif
     312          84 : DEFINE_BOOL(future, FUTURE_BOOL,
     313             :             "Implies all staged features that we want to ship in the "
     314             :             "not-too-far future")
     315             : 
     316      171179 : DEFINE_IMPLICATION(future, write_protect_code_memory)
     317             : 
     318             : // Flags for experimental implementation features.
     319          84 : DEFINE_BOOL(allocation_site_pretenuring, true,
     320             :             "pretenure with allocation sites")
     321          84 : DEFINE_BOOL(page_promotion, true, "promote pages based on utilization")
     322          84 : DEFINE_INT(page_promotion_threshold, 70,
     323             :            "min percentage of live bytes on a page to enable fast evacuation")
     324          84 : DEFINE_BOOL(trace_pretenuring, false,
     325             :             "trace pretenuring decisions of HAllocate instructions")
     326          84 : DEFINE_BOOL(trace_pretenuring_statistics, false,
     327             :             "trace allocation site pretenuring statistics")
     328          84 : DEFINE_BOOL(track_fields, true, "track fields with only smi values")
     329          84 : DEFINE_BOOL(track_double_fields, true, "track fields with double values")
     330          84 : DEFINE_BOOL(track_heap_object_fields, true, "track fields with heap values")
     331          84 : DEFINE_BOOL(track_computed_fields, true, "track computed boilerplate fields")
     332      171179 : DEFINE_IMPLICATION(track_double_fields, track_fields)
     333      171179 : DEFINE_IMPLICATION(track_heap_object_fields, track_fields)
     334      171179 : DEFINE_IMPLICATION(track_computed_fields, track_fields)
     335          84 : DEFINE_BOOL(track_field_types, true, "track field types")
     336      171179 : DEFINE_IMPLICATION(track_field_types, track_fields)
     337      171179 : DEFINE_IMPLICATION(track_field_types, track_heap_object_fields)
     338          84 : DEFINE_BOOL(trace_block_coverage, false,
     339             :             "trace collected block coverage information")
     340          84 : DEFINE_BOOL(feedback_normalization, false,
     341             :             "feed back normalization to constructors")
     342             : // TODO(jkummerow): This currently adds too much load on the stub cache.
     343             : DEFINE_BOOL_READONLY(internalize_on_the_fly, true,
     344             :                      "internalize string keys for generic keyed ICs on the fly")
     345             : 
     346             : // Flag to faster calls with arguments mismatches (https://crbug.com/v8/8895)
     347          84 : DEFINE_BOOL(fast_calls_with_arguments_mismatches, true,
     348             :             "skip arguments adaptor frames when it's provably safe")
     349             : 
     350             : // Flag for one shot optimiztions.
     351          84 : DEFINE_BOOL(enable_one_shot_optimization, true,
     352             :             "Enable size optimizations for the code that will "
     353             :             "only be executed once")
     354             : 
     355             : 
     356             : // Flags for data representation optimizations
     357          84 : DEFINE_BOOL(unbox_double_arrays, true, "automatically unbox arrays of doubles")
     358             : DEFINE_BOOL_READONLY(string_slices, true, "use string slices")
     359             : 
     360             : // Flags for Ignition for no-snapshot builds.
     361             : #undef FLAG
     362             : #ifndef V8_USE_SNAPSHOT
     363             : #define FLAG FLAG_FULL
     364             : #else
     365             : #define FLAG FLAG_READONLY
     366             : #endif
     367             : DEFINE_INT(interrupt_budget, 144 * KB,
     368             :            "interrupt budget which should be used for the profiler counter")
     369             : #undef FLAG
     370             : #define FLAG FLAG_FULL
     371             : 
     372             : // Flags for Ignition.
     373          84 : DEFINE_BOOL(ignition_elide_noneffectful_bytecodes, true,
     374             :             "elide bytecodes which won't have any external effect")
     375          84 : DEFINE_BOOL(ignition_reo, true, "use ignition register equivalence optimizer")
     376          84 : DEFINE_BOOL(ignition_filter_expression_positions, true,
     377             :             "filter expression positions before the bytecode pipeline")
     378          84 : DEFINE_BOOL(ignition_share_named_property_feedback, true,
     379             :             "share feedback slots when loading the same named property from "
     380             :             "the same object")
     381          84 : DEFINE_BOOL(print_bytecode, false,
     382             :             "print bytecode generated by ignition interpreter")
     383          84 : DEFINE_BOOL(enable_lazy_source_positions, V8_LITE_BOOL,
     384             :             "skip generating source positions during initial compile but "
     385             :             "regenerate when actually required")
     386          84 : DEFINE_STRING(print_bytecode_filter, "*",
     387             :               "filter for selecting which functions to print bytecode")
     388             : #ifdef V8_TRACE_IGNITION
     389             : DEFINE_BOOL(trace_ignition, false,
     390             :             "trace the bytecodes executed by the ignition interpreter")
     391             : #endif
     392             : #ifdef V8_TRACE_FEEDBACK_UPDATES
     393             : DEFINE_BOOL(
     394             :     trace_feedback_updates, false,
     395             :     "trace updates to feedback vectors during ignition interpreter execution.")
     396             : #endif
     397          84 : DEFINE_BOOL(trace_ignition_codegen, false,
     398             :             "trace the codegen of ignition interpreter bytecode handlers")
     399          84 : DEFINE_BOOL(trace_ignition_dispatches, false,
     400             :             "traces the dispatches to bytecode handlers by the ignition "
     401             :             "interpreter")
     402          84 : DEFINE_STRING(trace_ignition_dispatches_output_file, nullptr,
     403             :               "the file to which the bytecode handler dispatch table is "
     404             :               "written (by default, the table is not written to a file)")
     405             : 
     406          84 : DEFINE_BOOL(fast_math, true, "faster (but maybe less accurate) math functions")
     407          84 : DEFINE_BOOL(trace_track_allocation_sites, false,
     408             :             "trace the tracking of allocation sites")
     409          84 : DEFINE_BOOL(trace_migration, false, "trace object migration")
     410          84 : DEFINE_BOOL(trace_generalization, false, "trace map generalization")
     411             : 
     412             : // Flags for concurrent recompilation.
     413          84 : DEFINE_BOOL(concurrent_recompilation, true,
     414             :             "optimizing hot functions asynchronously on a separate thread")
     415          84 : DEFINE_BOOL(trace_concurrent_recompilation, false,
     416             :             "track concurrent recompilation")
     417          84 : DEFINE_INT(concurrent_recompilation_queue_length, 8,
     418             :            "the length of the concurrent compilation queue")
     419          84 : DEFINE_INT(concurrent_recompilation_delay, 0,
     420             :            "artificial compilation delay in ms")
     421          84 : DEFINE_BOOL(block_concurrent_recompilation, false,
     422             :             "block queued jobs until released")
     423          84 : DEFINE_BOOL(concurrent_inlining, false,
     424             :             "run optimizing compiler's inlining phase on a separate thread")
     425      171179 : DEFINE_IMPLICATION(future, concurrent_inlining)
     426          84 : DEFINE_BOOL(trace_heap_broker, false, "trace the heap broker")
     427             : 
     428             : // Flags for stress-testing the compiler.
     429          84 : DEFINE_INT(stress_runs, 0, "number of stress runs")
     430          84 : DEFINE_INT(deopt_every_n_times, 0,
     431             :            "deoptimize every n times a deopt point is passed")
     432          84 : DEFINE_BOOL(print_deopt_stress, false, "print number of possible deopt points")
     433             : 
     434             : // Flags for TurboFan.
     435          84 : DEFINE_BOOL(turbo_sp_frame_access, false,
     436             :             "use stack pointer-relative access to frame wherever possible")
     437          84 : DEFINE_BOOL(turbo_preprocess_ranges, true,
     438             :             "run pre-register allocation heuristics")
     439          84 : DEFINE_BOOL(turbo_control_flow_aware_allocation, false,
     440             :             "consider control flow while allocating registers")
     441      171179 : DEFINE_NEG_IMPLICATION(turbo_control_flow_aware_allocation,
     442             :                        turbo_preprocess_ranges)
     443             : 
     444          84 : DEFINE_STRING(turbo_filter, "*", "optimization filter for TurboFan compiler")
     445          84 : DEFINE_BOOL(trace_turbo, false, "trace generated TurboFan IR")
     446          84 : DEFINE_STRING(trace_turbo_path, nullptr,
     447             :               "directory to dump generated TurboFan IR to")
     448          84 : DEFINE_STRING(trace_turbo_filter, "*",
     449             :               "filter for tracing turbofan compilation")
     450          84 : DEFINE_BOOL(trace_turbo_graph, false, "trace generated TurboFan graphs")
     451          84 : DEFINE_BOOL(trace_turbo_scheduled, false, "trace TurboFan IR with schedule")
     452      171179 : DEFINE_IMPLICATION(trace_turbo_scheduled, trace_turbo_graph)
     453          84 : DEFINE_STRING(trace_turbo_cfg_file, nullptr,
     454             :               "trace turbo cfg graph (for C1 visualizer) to a given file name")
     455          84 : DEFINE_BOOL(trace_turbo_types, true, "trace TurboFan's types")
     456          84 : DEFINE_BOOL(trace_turbo_scheduler, false, "trace TurboFan's scheduler")
     457          84 : DEFINE_BOOL(trace_turbo_reduction, false, "trace TurboFan's various reducers")
     458          84 : DEFINE_BOOL(trace_turbo_trimming, false, "trace TurboFan's graph trimmer")
     459          84 : DEFINE_BOOL(trace_turbo_jt, false, "trace TurboFan's jump threading")
     460          84 : DEFINE_BOOL(trace_turbo_ceq, false, "trace TurboFan's control equivalence")
     461          84 : DEFINE_BOOL(trace_turbo_loop, false, "trace TurboFan's loop optimizations")
     462          84 : DEFINE_BOOL(trace_alloc, false, "trace register allocator")
     463          84 : DEFINE_BOOL(trace_all_uses, false, "trace all use positions")
     464          84 : DEFINE_BOOL(trace_representation, false, "trace representation types")
     465          84 : DEFINE_BOOL(turbo_verify, DEBUG_BOOL, "verify TurboFan graphs at each phase")
     466          84 : DEFINE_STRING(turbo_verify_machine_graph, nullptr,
     467             :               "verify TurboFan machine graph before instruction selection")
     468             : #ifdef ENABLE_VERIFY_CSA
     469             : DEFINE_BOOL(verify_csa, DEBUG_BOOL,
     470             :             "verify TurboFan machine graph of code stubs")
     471             : #else
     472             : // Define the flag as read-only-false so that code still compiles even in the
     473             : // non-ENABLE_VERIFY_CSA configuration.
     474             : DEFINE_BOOL_READONLY(verify_csa, false,
     475             :                      "verify TurboFan machine graph of code stubs")
     476             : #endif
     477          84 : DEFINE_BOOL(trace_verify_csa, false, "trace code stubs verification")
     478          84 : DEFINE_STRING(csa_trap_on_node, nullptr,
     479             :               "trigger break point when a node with given id is created in "
     480             :               "given stub. The format is: StubName,NodeId")
     481             : DEFINE_BOOL_READONLY(fixed_array_bounds_checks, true,
     482             :                      "enable FixedArray bounds checks")
     483          84 : DEFINE_BOOL(turbo_stats, false, "print TurboFan statistics")
     484          84 : DEFINE_BOOL(turbo_stats_nvp, false,
     485             :             "print TurboFan statistics in machine-readable format")
     486          84 : DEFINE_BOOL(turbo_stats_wasm, false,
     487             :             "print TurboFan statistics of wasm compilations")
     488          84 : DEFINE_BOOL(turbo_splitting, true, "split nodes during scheduling in TurboFan")
     489          84 : DEFINE_BOOL(function_context_specialization, false,
     490             :             "enable function context specialization in TurboFan")
     491          84 : DEFINE_BOOL(turbo_inlining, true, "enable inlining in TurboFan")
     492          84 : DEFINE_INT(max_inlined_bytecode_size, 500,
     493             :            "maximum size of bytecode for a single inlining")
     494          84 : DEFINE_INT(max_inlined_bytecode_size_cumulative, 1000,
     495             :            "maximum cumulative size of bytecode considered for inlining")
     496          84 : DEFINE_INT(max_inlined_bytecode_size_absolute, 5000,
     497             :            "maximum cumulative size of bytecode considered for inlining")
     498          84 : DEFINE_FLOAT(reserve_inline_budget_scale_factor, 1.2,
     499             :              "maximum cumulative size of bytecode considered for inlining")
     500          84 : DEFINE_INT(max_inlined_bytecode_size_small, 30,
     501             :            "maximum size of bytecode considered for small function inlining")
     502          84 : DEFINE_FLOAT(min_inlining_frequency, 0.15, "minimum frequency for inlining")
     503          84 : DEFINE_BOOL(polymorphic_inlining, true, "polymorphic inlining")
     504          84 : DEFINE_BOOL(stress_inline, false,
     505             :             "set high thresholds for inlining to inline as much as possible")
     506      171179 : DEFINE_VALUE_IMPLICATION(stress_inline, max_inlined_bytecode_size, 999999)
     507      171179 : DEFINE_VALUE_IMPLICATION(stress_inline, max_inlined_bytecode_size_cumulative,
     508             :                          999999)
     509      171179 : DEFINE_VALUE_IMPLICATION(stress_inline, max_inlined_bytecode_size_absolute,
     510             :                          999999)
     511      171179 : DEFINE_VALUE_IMPLICATION(stress_inline, min_inlining_frequency, 0)
     512      171179 : DEFINE_VALUE_IMPLICATION(stress_inline, polymorphic_inlining, true)
     513          84 : DEFINE_BOOL(trace_turbo_inlining, false, "trace TurboFan inlining")
     514          84 : DEFINE_BOOL(inline_accessors, true, "inline JavaScript accessors")
     515          84 : DEFINE_BOOL(inline_into_try, true, "inline into try blocks")
     516          84 : DEFINE_BOOL(turbo_inline_array_builtins, true,
     517             :             "inline array builtins in TurboFan code")
     518          84 : DEFINE_BOOL(use_osr, true, "use on-stack replacement")
     519          84 : DEFINE_BOOL(trace_osr, false, "trace on-stack replacement")
     520          84 : DEFINE_BOOL(analyze_environment_liveness, true,
     521             :             "analyze liveness of environment slots and zap dead values")
     522          84 : DEFINE_BOOL(trace_environment_liveness, false,
     523             :             "trace liveness of local variable slots")
     524          84 : DEFINE_BOOL(turbo_load_elimination, true, "enable load elimination in TurboFan")
     525          84 : DEFINE_BOOL(trace_turbo_load_elimination, false,
     526             :             "trace TurboFan load elimination")
     527          84 : DEFINE_BOOL(turbo_profiling, false, "enable profiling in TurboFan")
     528          84 : DEFINE_BOOL(turbo_verify_allocation, DEBUG_BOOL,
     529             :             "verify register allocation in TurboFan")
     530          84 : DEFINE_BOOL(turbo_move_optimization, true, "optimize gap moves in TurboFan")
     531          84 : DEFINE_BOOL(turbo_jt, true, "enable jump threading in TurboFan")
     532          84 : DEFINE_BOOL(turbo_loop_peeling, true, "Turbofan loop peeling")
     533          84 : DEFINE_BOOL(turbo_loop_variable, true, "Turbofan loop variable optimization")
     534          84 : DEFINE_BOOL(turbo_loop_rotation, true, "Turbofan loop rotation")
     535          84 : DEFINE_BOOL(turbo_cf_optimization, true, "optimize control flow in TurboFan")
     536          84 : DEFINE_BOOL(turbo_escape, true, "enable escape analysis")
     537          84 : DEFINE_BOOL(turbo_allocation_folding, true, "Turbofan allocation folding")
     538          84 : DEFINE_BOOL(turbo_instruction_scheduling, false,
     539             :             "enable instruction scheduling in TurboFan")
     540          84 : DEFINE_BOOL(turbo_stress_instruction_scheduling, false,
     541             :             "randomly schedule instructions to stress dependency tracking")
     542          84 : DEFINE_BOOL(turbo_store_elimination, true,
     543             :             "enable store-store elimination in TurboFan")
     544          84 : DEFINE_BOOL(trace_store_elimination, false, "trace store elimination")
     545          84 : DEFINE_BOOL(turbo_rewrite_far_jumps, true,
     546             :             "rewrite far to near jumps (ia32,x64)")
     547          84 : DEFINE_BOOL(experimental_inline_promise_constructor, true,
     548             :             "inline the Promise constructor in TurboFan")
     549          84 : DEFINE_BOOL(
     550             :     stress_gc_during_compilation, false,
     551             :     "simulate GC/compiler thread race related to https://crbug.com/v8/8520")
     552             : 
     553             : #ifdef DISABLE_UNTRUSTED_CODE_MITIGATIONS
     554             : #define V8_DEFAULT_UNTRUSTED_CODE_MITIGATIONS false
     555             : #else
     556             : #define V8_DEFAULT_UNTRUSTED_CODE_MITIGATIONS true
     557             : #endif
     558          84 : DEFINE_BOOL(untrusted_code_mitigations, V8_DEFAULT_UNTRUSTED_CODE_MITIGATIONS,
     559             :             "Enable mitigations for executing untrusted code")
     560             : #undef V8_DEFAULT_UNTRUSTED_CODE_MITIGATIONS
     561             : 
     562             : // Flags for native WebAssembly.
     563          84 : DEFINE_BOOL(expose_wasm, true, "expose wasm interface to JavaScript")
     564          84 : DEFINE_BOOL(assume_asmjs_origin, false,
     565             :             "force wasm decoder to assume input is internal asm-wasm format")
     566          84 : DEFINE_BOOL(wasm_disable_structured_cloning, false,
     567             :             "disable wasm structured cloning")
     568          84 : DEFINE_INT(wasm_num_compilation_tasks, 10,
     569             :            "number of parallel compilation tasks for wasm")
     570             : DEFINE_DEBUG_BOOL(trace_wasm_native_heap, false,
     571             :                   "trace wasm native heap events")
     572          84 : DEFINE_BOOL(wasm_write_protect_code_memory, false,
     573             :             "write protect code memory on the wasm native heap")
     574          84 : DEFINE_BOOL(trace_wasm_serialization, false,
     575             :             "trace serialization/deserialization")
     576          84 : DEFINE_BOOL(wasm_async_compilation, true,
     577             :             "enable actual asynchronous compilation for WebAssembly.compile")
     578          84 : DEFINE_BOOL(wasm_test_streaming, false,
     579             :             "use streaming compilation instead of async compilation for tests")
     580          84 : DEFINE_UINT(wasm_max_mem_pages, v8::internal::wasm::kV8MaxWasmMemoryPages,
     581             :             "maximum number of 64KiB memory pages of a wasm instance")
     582          84 : DEFINE_UINT(wasm_max_table_size, v8::internal::wasm::kV8MaxWasmTableSize,
     583             :             "maximum table size of a wasm instance")
     584          84 : DEFINE_UINT(wasm_max_code_space, v8::internal::kMaxWasmCodeMB,
     585             :             "maximum committed code space for wasm (in MB)")
     586             : // Enable Liftoff by default on ia32 and x64. More architectures will follow
     587             : // once they are implemented and sufficiently tested.
     588             : #if V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_X64
     589          84 : DEFINE_BOOL(
     590             :     wasm_tier_up, true,
     591             :     "enable wasm baseline compilation and tier up to the optimizing compiler")
     592             : #else
     593             : DEFINE_BOOL(
     594             :     wasm_tier_up, false,
     595             :     "enable wasm baseline compilation and tier up to the optimizing compiler")
     596             : DEFINE_IMPLICATION(future, wasm_tier_up)
     597             : #endif
     598      171179 : DEFINE_IMPLICATION(wasm_tier_up, liftoff)
     599             : DEFINE_DEBUG_BOOL(trace_wasm_decoder, false, "trace decoding of wasm code")
     600             : DEFINE_DEBUG_BOOL(trace_wasm_decode_time, false,
     601             :                   "trace decoding time of wasm code")
     602             : DEFINE_DEBUG_BOOL(trace_wasm_compiler, false, "trace compiling of wasm code")
     603             : DEFINE_DEBUG_BOOL(trace_wasm_interpreter, false,
     604             :                   "trace interpretation of wasm code")
     605             : DEFINE_DEBUG_BOOL(trace_wasm_streaming, false,
     606             :                   "trace streaming compilation of wasm code")
     607          84 : DEFINE_INT(trace_wasm_ast_start, 0,
     608             :            "start function for wasm AST trace (inclusive)")
     609          84 : DEFINE_INT(trace_wasm_ast_end, 0, "end function for wasm AST trace (exclusive)")
     610          84 : DEFINE_BOOL(liftoff, false,
     611             :             "enable Liftoff, the baseline compiler for WebAssembly")
     612             : DEFINE_DEBUG_BOOL(trace_liftoff, false,
     613             :                   "trace Liftoff, the baseline compiler for WebAssembly")
     614             : DEFINE_DEBUG_BOOL(wasm_break_on_decoder_error, false,
     615             :                   "debug break when wasm decoder encounters an error")
     616          84 : DEFINE_BOOL(trace_wasm_memory, false,
     617             :             "print all memory updates performed in wasm code")
     618             : // Fuzzers use {wasm_tier_mask_for_testing} together with {liftoff} and
     619             : // {no_wasm_tier_up} to force some functions to be compiled with Turbofan.
     620          84 : DEFINE_INT(wasm_tier_mask_for_testing, 0,
     621             :            "bitmask of functions to compile with TurboFan instead of Liftoff")
     622             : 
     623          84 : DEFINE_BOOL(validate_asm, true, "validate asm.js modules before compiling")
     624          84 : DEFINE_BOOL(suppress_asm_messages, false,
     625             :             "don't emit asm.js related messages (for golden file testing)")
     626          84 : DEFINE_BOOL(trace_asm_time, false, "log asm.js timing info to the console")
     627          84 : DEFINE_BOOL(trace_asm_scanner, false,
     628             :             "log tokens encountered by asm.js scanner")
     629          84 : DEFINE_BOOL(trace_asm_parser, false, "verbose logging of asm.js parse failures")
     630          84 : DEFINE_BOOL(stress_validate_asm, false, "try to validate everything as asm.js")
     631             : 
     632             : DEFINE_DEBUG_BOOL(dump_wasm_module, false, "dump wasm module bytes")
     633          84 : DEFINE_STRING(dump_wasm_module_path, nullptr,
     634             :               "directory to dump wasm modules to")
     635             : 
     636             : // Declare command-line flags for WASM features. Warning: avoid using these
     637             : // flags directly in the implementation. Instead accept wasm::WasmFeatures
     638             : // for configurability.
     639             : #include "src/wasm/wasm-feature-flags.h"
     640             : 
     641             : #define SPACE
     642             : #define DECL_WASM_FLAG(feat, desc, val)      \
     643             :   DEFINE_BOOL(experimental_wasm_##feat, val, \
     644             :               "enable prototype " desc " for wasm")
     645          84 : FOREACH_WASM_FEATURE_FLAG(DECL_WASM_FLAG, SPACE)
     646             : #undef DECL_WASM_FLAG
     647             : #undef SPACE
     648             : 
     649          84 : DEFINE_BOOL(wasm_opt, false, "enable wasm optimization")
     650          84 : DEFINE_BOOL(wasm_no_bounds_checks, false,
     651             :             "disable bounds checks (performance testing only)")
     652          84 : DEFINE_BOOL(wasm_no_stack_checks, false,
     653             :             "disable stack checks (performance testing only)")
     654          84 : DEFINE_BOOL(wasm_math_intrinsics, true,
     655             :             "intrinsify some Math imports into wasm")
     656             : 
     657          84 : DEFINE_BOOL(wasm_shared_engine, true,
     658             :             "shares one wasm engine between all isolates within a process")
     659      171179 : DEFINE_IMPLICATION(future, wasm_shared_engine)
     660          84 : DEFINE_BOOL(wasm_shared_code, true,
     661             :             "shares code underlying a wasm module when it is transferred")
     662      171179 : DEFINE_IMPLICATION(future, wasm_shared_code)
     663          84 : DEFINE_BOOL(wasm_trap_handler, true,
     664             :             "use signal handlers to catch out of bounds memory access in wasm"
     665             :             " (currently Linux x86_64 only)")
     666          84 : DEFINE_BOOL(wasm_trap_handler_fallback, false,
     667             :             "Use bounds checks if guarded memory is not available")
     668          84 : DEFINE_BOOL(wasm_fuzzer_gen_test, false,
     669             :             "Generate a test case when running a wasm fuzzer")
     670      171179 : DEFINE_IMPLICATION(wasm_fuzzer_gen_test, single_threaded)
     671          84 : DEFINE_BOOL(print_wasm_code, false, "Print WebAssembly code")
     672          84 : DEFINE_BOOL(print_wasm_stub_code, false, "Print WebAssembly stub code")
     673          84 : DEFINE_BOOL(wasm_interpret_all, false,
     674             :             "Execute all wasm code in the wasm interpreter")
     675          84 : DEFINE_BOOL(asm_wasm_lazy_compilation, false,
     676             :             "enable lazy compilation for asm-wasm modules")
     677      171179 : DEFINE_IMPLICATION(validate_asm, asm_wasm_lazy_compilation)
     678          84 : DEFINE_BOOL(wasm_lazy_compilation, false,
     679             :             "enable lazy compilation for all wasm modules")
     680             : DEFINE_DEBUG_BOOL(trace_wasm_lazy_compilation, false,
     681             :                   "trace lazy compilation of wasm functions")
     682             : // wasm-interpret-all resets {asm-,}wasm-lazy-compilation.
     683      171179 : DEFINE_NEG_IMPLICATION(wasm_interpret_all, asm_wasm_lazy_compilation)
     684      171179 : DEFINE_NEG_IMPLICATION(wasm_interpret_all, wasm_lazy_compilation)
     685      171179 : DEFINE_NEG_IMPLICATION(wasm_interpret_all, wasm_tier_up)
     686             : 
     687             : // Profiler flags.
     688          84 : DEFINE_INT(frame_count, 1, "number of stack frames inspected by the profiler")
     689          84 : DEFINE_INT(type_info_threshold, 25,
     690             :            "percentage of ICs that must have type info to allow optimization")
     691             : 
     692          84 : DEFINE_INT(stress_sampling_allocation_profiler, 0,
     693             :            "Enables sampling allocation profiler with X as a sample interval")
     694             : 
     695             : // Garbage collections flags.
     696          84 : DEFINE_SIZE_T(min_semi_space_size, 0,
     697             :               "min size of a semi-space (in MBytes), the new space consists of "
     698             :               "two semi-spaces")
     699          84 : DEFINE_SIZE_T(max_semi_space_size, 0,
     700             :               "max size of a semi-space (in MBytes), the new space consists of "
     701             :               "two semi-spaces")
     702          84 : DEFINE_INT(semi_space_growth_factor, 2, "factor by which to grow the new space")
     703          84 : DEFINE_BOOL(experimental_new_space_growth_heuristic, false,
     704             :             "Grow the new space based on the percentage of survivors instead "
     705             :             "of their absolute value.")
     706          84 : DEFINE_SIZE_T(max_old_space_size, 0, "max size of the old space (in Mbytes)")
     707          84 : DEFINE_SIZE_T(initial_old_space_size, 0, "initial old space size (in Mbytes)")
     708          84 : DEFINE_BOOL(gc_global, false, "always perform global GCs")
     709          84 : DEFINE_INT(random_gc_interval, 0,
     710             :            "Collect garbage after random(0, X) allocations. It overrides "
     711             :            "gc_interval.")
     712          84 : DEFINE_INT(gc_interval, -1, "garbage collect after <n> allocations")
     713          84 : DEFINE_INT(retain_maps_for_n_gc, 2,
     714             :            "keeps maps alive for <n> old space garbage collections")
     715          84 : DEFINE_BOOL(trace_gc, false,
     716             :             "print one trace line following each garbage collection")
     717          84 : DEFINE_BOOL(trace_gc_nvp, false,
     718             :             "print one detailed trace line in name=value format "
     719             :             "after each garbage collection")
     720          84 : DEFINE_BOOL(trace_gc_ignore_scavenger, false,
     721             :             "do not print trace line after scavenger collection")
     722          84 : DEFINE_BOOL(trace_idle_notification, false,
     723             :             "print one trace line following each idle notification")
     724          84 : DEFINE_BOOL(trace_idle_notification_verbose, false,
     725             :             "prints the heap state used by the idle notification")
     726          84 : DEFINE_BOOL(trace_gc_verbose, false,
     727             :             "print more details following each garbage collection")
     728      171179 : DEFINE_IMPLICATION(trace_gc_verbose, trace_gc)
     729             : 
     730          84 : DEFINE_INT(trace_allocation_stack_interval, -1,
     731             :            "print stack trace after <n> free-list allocations")
     732          84 : DEFINE_INT(trace_duplicate_threshold_kb, 0,
     733             :            "print duplicate objects in the heap if their size is more than "
     734             :            "given threshold")
     735          84 : DEFINE_BOOL(trace_fragmentation, false, "report fragmentation for old space")
     736          84 : DEFINE_BOOL(trace_fragmentation_verbose, false,
     737             :             "report fragmentation for old space (detailed)")
     738          84 : DEFINE_BOOL(trace_evacuation, false, "report evacuation statistics")
     739          84 : DEFINE_BOOL(trace_mutator_utilization, false,
     740             :             "print mutator utilization, allocation speed, gc speed")
     741          84 : DEFINE_BOOL(incremental_marking, true, "use incremental marking")
     742          84 : DEFINE_BOOL(incremental_marking_wrappers, true,
     743             :             "use incremental marking for marking wrappers")
     744          84 : DEFINE_BOOL(trace_unmapper, false, "Trace the unmapping")
     745          84 : DEFINE_BOOL(parallel_scavenge, true, "parallel scavenge")
     746          84 : DEFINE_BOOL(trace_parallel_scavenge, false, "trace parallel scavenge")
     747          84 : DEFINE_BOOL(write_protect_code_memory, true, "write protect code memory")
     748             : #ifdef V8_CONCURRENT_MARKING
     749             : #define V8_CONCURRENT_MARKING_BOOL true
     750             : #else
     751             : #define V8_CONCURRENT_MARKING_BOOL false
     752             : #endif
     753          84 : DEFINE_BOOL(concurrent_marking, V8_CONCURRENT_MARKING_BOOL,
     754             :             "use concurrent marking")
     755          84 : DEFINE_BOOL(parallel_marking, true, "use parallel marking in atomic pause")
     756          84 : DEFINE_INT(ephemeron_fixpoint_iterations, 10,
     757             :            "number of fixpoint iterations it takes to switch to linear "
     758             :            "ephemeron algorithm")
     759          84 : DEFINE_BOOL(trace_concurrent_marking, false, "trace concurrent marking")
     760          84 : DEFINE_BOOL(concurrent_store_buffer, true,
     761             :             "use concurrent store buffer processing")
     762          84 : DEFINE_BOOL(concurrent_sweeping, true, "use concurrent sweeping")
     763          84 : DEFINE_BOOL(parallel_compaction, true, "use parallel compaction")
     764          84 : DEFINE_BOOL(parallel_pointer_update, true,
     765             :             "use parallel pointer update during compaction")
     766          84 : DEFINE_BOOL(detect_ineffective_gcs_near_heap_limit, true,
     767             :             "trigger out-of-memory failure to avoid GC storm near heap limit")
     768          84 : DEFINE_BOOL(trace_incremental_marking, false,
     769             :             "trace progress of the incremental marking")
     770          84 : DEFINE_BOOL(trace_stress_marking, false, "trace stress marking progress")
     771          84 : DEFINE_BOOL(trace_stress_scavenge, false, "trace stress scavenge progress")
     772          84 : DEFINE_BOOL(track_gc_object_stats, false,
     773             :             "track object counts and memory usage")
     774          84 : DEFINE_BOOL(trace_gc_object_stats, false,
     775             :             "trace object counts and memory usage")
     776          84 : DEFINE_BOOL(trace_zone_stats, false, "trace zone memory usage")
     777          84 : DEFINE_BOOL(track_retaining_path, false,
     778             :             "enable support for tracking retaining path")
     779          84 : DEFINE_BOOL(concurrent_array_buffer_freeing, true,
     780             :             "free array buffer allocations on a background thread")
     781          84 : DEFINE_INT(gc_stats, 0, "Used by tracing internally to enable gc statistics")
     782      171179 : DEFINE_IMPLICATION(trace_gc_object_stats, track_gc_object_stats)
     783      171179 : DEFINE_GENERIC_IMPLICATION(
     784             :     track_gc_object_stats,
     785             :     TracingFlags::gc_stats.store(
     786             :         v8::tracing::TracingCategoryObserver::ENABLED_BY_NATIVE))
     787      171179 : DEFINE_GENERIC_IMPLICATION(
     788             :     trace_gc_object_stats,
     789             :     TracingFlags::gc_stats.store(
     790             :         v8::tracing::TracingCategoryObserver::ENABLED_BY_NATIVE))
     791      171179 : DEFINE_NEG_IMPLICATION(trace_gc_object_stats, incremental_marking)
     792      171179 : DEFINE_NEG_IMPLICATION(track_retaining_path, incremental_marking)
     793      171179 : DEFINE_NEG_IMPLICATION(track_retaining_path, parallel_marking)
     794      171179 : DEFINE_NEG_IMPLICATION(track_retaining_path, concurrent_marking)
     795          84 : DEFINE_BOOL(track_detached_contexts, true,
     796             :             "track native contexts that are expected to be garbage collected")
     797          84 : DEFINE_BOOL(trace_detached_contexts, false,
     798             :             "trace native contexts that are expected to be garbage collected")
     799      171179 : DEFINE_IMPLICATION(trace_detached_contexts, track_detached_contexts)
     800             : #ifdef VERIFY_HEAP
     801             : DEFINE_BOOL(verify_heap, false, "verify heap pointers before and after GC")
     802             : DEFINE_BOOL(verify_heap_skip_remembered_set, false,
     803             :             "disable remembered set verification")
     804             : #endif
     805          84 : DEFINE_BOOL(move_object_start, true, "enable moving of object starts")
     806          84 : DEFINE_BOOL(memory_reducer, true, "use memory reducer")
     807          84 : DEFINE_BOOL(memory_reducer_for_small_heaps, true,
     808             :             "use memory reducer for small heaps")
     809          84 : DEFINE_INT(heap_growing_percent, 0,
     810             :            "specifies heap growing factor as (1 + heap_growing_percent/100)")
     811          84 : DEFINE_INT(v8_os_page_size, 0, "override OS page size (in KBytes)")
     812          84 : DEFINE_BOOL(always_compact, false, "Perform compaction on every full GC")
     813          84 : DEFINE_BOOL(never_compact, false,
     814             :             "Never perform compaction on full GC - testing only")
     815          84 : DEFINE_BOOL(compact_code_space, true, "Compact code space on full collections")
     816          84 : DEFINE_BOOL(flush_bytecode, true,
     817             :             "flush of bytecode when it has not been executed recently")
     818          84 : DEFINE_BOOL(stress_flush_bytecode, false, "stress bytecode flushing")
     819      171179 : DEFINE_IMPLICATION(stress_flush_bytecode, flush_bytecode)
     820          84 : DEFINE_BOOL(use_marking_progress_bar, true,
     821             :             "Use a progress bar to scan large objects in increments when "
     822             :             "incremental marking is active.")
     823          84 : DEFINE_BOOL(force_marking_deque_overflows, false,
     824             :             "force overflows of marking deque by reducing it's size "
     825             :             "to 64 words")
     826          84 : DEFINE_BOOL(stress_compaction, false,
     827             :             "stress the GC compactor to flush out bugs (implies "
     828             :             "--force_marking_deque_overflows)")
     829          84 : DEFINE_BOOL(stress_compaction_random, false,
     830             :             "Stress GC compaction by selecting random percent of pages as "
     831             :             "evacuation candidates. It overrides stress_compaction.")
     832          84 : DEFINE_BOOL(stress_incremental_marking, false,
     833             :             "force incremental marking for small heaps and run it more often")
     834             : 
     835          84 : DEFINE_BOOL(fuzzer_gc_analysis, false,
     836             :             "prints number of allocations and enables analysis mode for gc "
     837             :             "fuzz testing, e.g. --stress-marking, --stress-scavenge")
     838          84 : DEFINE_INT(stress_marking, 0,
     839             :            "force marking at random points between 0 and X (inclusive) percent "
     840             :            "of the regular marking start limit")
     841          84 : DEFINE_INT(stress_scavenge, 0,
     842             :            "force scavenge at random points between 0 and X (inclusive) "
     843             :            "percent of the new space capacity")
     844      171179 : DEFINE_IMPLICATION(fuzzer_gc_analysis, stress_marking)
     845      171179 : DEFINE_IMPLICATION(fuzzer_gc_analysis, stress_scavenge)
     846             : 
     847          84 : DEFINE_BOOL(disable_abortjs, false, "disables AbortJS runtime function")
     848             : 
     849          84 : DEFINE_BOOL(manual_evacuation_candidates_selection, false,
     850             :             "Test mode only flag. It allows an unit test to select evacuation "
     851             :             "candidates pages (requires --stress_compaction).")
     852          84 : DEFINE_BOOL(fast_promotion_new_space, false,
     853             :             "fast promote new space on high survival rates")
     854             : 
     855          84 : DEFINE_BOOL(clear_free_memory, false, "initialize free memory with 0")
     856             : 
     857          84 : DEFINE_BOOL(young_generation_large_objects, true,
     858             :             "allocates large objects by default in the young generation large "
     859             :             "object space")
     860             : 
     861          84 : DEFINE_BOOL(idle_time_scavenge, true, "Perform scavenges in idle time.")
     862             : 
     863             : // assembler-ia32.cc / assembler-arm.cc / assembler-x64.cc
     864          84 : DEFINE_BOOL(debug_code, DEBUG_BOOL,
     865             :             "generate extra code (assertions) for debugging")
     866          84 : DEFINE_BOOL(code_comments, false,
     867             :             "emit comments in code disassembly; for more readable source "
     868             :             "positions you should add --no-concurrent_recompilation")
     869          84 : DEFINE_BOOL(enable_sse3, true, "enable use of SSE3 instructions if available")
     870          84 : DEFINE_BOOL(enable_ssse3, true, "enable use of SSSE3 instructions if available")
     871          84 : DEFINE_BOOL(enable_sse4_1, true,
     872             :             "enable use of SSE4.1 instructions if available")
     873          84 : DEFINE_BOOL(enable_sahf, true,
     874             :             "enable use of SAHF instruction if available (X64 only)")
     875          84 : DEFINE_BOOL(enable_avx, true, "enable use of AVX instructions if available")
     876          84 : DEFINE_BOOL(enable_fma3, true, "enable use of FMA3 instructions if available")
     877          84 : DEFINE_BOOL(enable_bmi1, true, "enable use of BMI1 instructions if available")
     878          84 : DEFINE_BOOL(enable_bmi2, true, "enable use of BMI2 instructions if available")
     879          84 : DEFINE_BOOL(enable_lzcnt, true, "enable use of LZCNT instruction if available")
     880          84 : DEFINE_BOOL(enable_popcnt, true,
     881             :             "enable use of POPCNT instruction if available")
     882          84 : DEFINE_STRING(arm_arch, ARM_ARCH_DEFAULT,
     883             :               "generate instructions for the selected ARM architecture if "
     884             :               "available: armv6, armv7, armv7+sudiv or armv8")
     885          84 : DEFINE_BOOL(force_long_branches, false,
     886             :             "force all emitted branches to be in long mode (MIPS/PPC only)")
     887          84 : DEFINE_STRING(mcpu, "auto", "enable optimization for specific cpu")
     888          84 : DEFINE_BOOL(partial_constant_pool, true,
     889             :             "enable use of partial constant pools (X64 only)")
     890             : 
     891             : // Controlling source positions for Torque/CSA code.
     892          84 : DEFINE_BOOL(enable_source_at_csa_bind, false,
     893             :             "Include source information in the binary at CSA bind locations.")
     894             : 
     895             : // Deprecated ARM flags (replaced by arm_arch).
     896          84 : DEFINE_MAYBE_BOOL(enable_armv7, "deprecated (use --arm_arch instead)")
     897          84 : DEFINE_MAYBE_BOOL(enable_vfp3, "deprecated (use --arm_arch instead)")
     898          84 : DEFINE_MAYBE_BOOL(enable_32dregs, "deprecated (use --arm_arch instead)")
     899          84 : DEFINE_MAYBE_BOOL(enable_neon, "deprecated (use --arm_arch instead)")
     900          84 : DEFINE_MAYBE_BOOL(enable_sudiv, "deprecated (use --arm_arch instead)")
     901          84 : DEFINE_MAYBE_BOOL(enable_armv8, "deprecated (use --arm_arch instead)")
     902             : 
     903             : // regexp-macro-assembler-*.cc
     904          84 : DEFINE_BOOL(enable_regexp_unaligned_accesses, true,
     905             :             "enable unaligned accesses for the regexp engine")
     906             : 
     907             : // api.cc
     908          84 : DEFINE_BOOL(script_streaming, true, "enable parsing on background")
     909          84 : DEFINE_BOOL(disable_old_api_accessors, false,
     910             :             "Disable old-style API accessors whose setters trigger through the "
     911             :             "prototype chain")
     912             : 
     913             : // bootstrapper.cc
     914          84 : DEFINE_BOOL(expose_free_buffer, false, "expose freeBuffer extension")
     915          84 : DEFINE_BOOL(expose_gc, false, "expose gc extension")
     916          84 : DEFINE_STRING(expose_gc_as, nullptr,
     917             :               "expose gc extension under the specified name")
     918      171179 : DEFINE_IMPLICATION(expose_gc_as, expose_gc)
     919          84 : DEFINE_BOOL(expose_externalize_string, false,
     920             :             "expose externalize string extension")
     921          84 : DEFINE_BOOL(expose_trigger_failure, false, "expose trigger-failure extension")
     922          84 : DEFINE_INT(stack_trace_limit, 10, "number of stack frames to capture")
     923          84 : DEFINE_BOOL(builtins_in_stack_traces, false,
     924             :             "show built-in functions in stack traces")
     925          84 : DEFINE_BOOL(disallow_code_generation_from_strings, false,
     926             :             "disallow eval and friends")
     927          84 : DEFINE_BOOL(expose_async_hooks, false, "expose async_hooks object")
     928             : 
     929             : // builtins.cc
     930          84 : DEFINE_BOOL(allow_unsafe_function_constructor, false,
     931             :             "allow invoking the function constructor without security checks")
     932          84 : DEFINE_BOOL(force_slow_path, false, "always take the slow path for builtins")
     933          84 : DEFINE_BOOL(test_small_max_function_context_stub_size, false,
     934             :             "enable testing the function context size overflow path "
     935             :             "by making the maximum size smaller")
     936             : 
     937             : // builtins-ia32.cc
     938          84 : DEFINE_BOOL(inline_new, true, "use fast inline allocation")
     939             : 
     940             : // codegen-ia32.cc / codegen-arm.cc
     941          84 : DEFINE_BOOL(trace, false, "trace function calls")
     942             : 
     943             : // codegen.cc
     944          84 : DEFINE_BOOL(lazy, true, "use lazy compilation")
     945          84 : DEFINE_BOOL(max_lazy, false, "ignore eager compilation hints")
     946      171179 : DEFINE_IMPLICATION(max_lazy, lazy)
     947          84 : DEFINE_BOOL(trace_opt, false, "trace lazy optimization")
     948          84 : DEFINE_BOOL(trace_opt_verbose, false, "extra verbose compilation tracing")
     949      171179 : DEFINE_IMPLICATION(trace_opt_verbose, trace_opt)
     950          84 : DEFINE_BOOL(trace_opt_stats, false, "trace lazy optimization statistics")
     951          84 : DEFINE_BOOL(trace_deopt, false, "trace optimize function deoptimization")
     952          84 : DEFINE_BOOL(trace_file_names, false,
     953             :             "include file names in trace-opt/trace-deopt output")
     954          84 : DEFINE_BOOL(trace_interrupts, false, "trace interrupts when they are handled")
     955          84 : DEFINE_BOOL(always_opt, false, "always try to optimize functions")
     956          84 : DEFINE_BOOL(always_osr, false, "always try to OSR functions")
     957          84 : DEFINE_BOOL(prepare_always_opt, false, "prepare for turning on always opt")
     958             : 
     959          84 : DEFINE_BOOL(trace_serializer, false, "print code serializer trace")
     960             : #ifdef DEBUG
     961             : DEFINE_BOOL(external_reference_stats, false,
     962             :             "print statistics on external references used during serialization")
     963             : #endif  // DEBUG
     964             : 
     965             : // compilation-cache.cc
     966          84 : DEFINE_BOOL(compilation_cache, true, "enable compilation cache")
     967             : 
     968          84 : DEFINE_BOOL(cache_prototype_transitions, true, "cache prototype transitions")
     969             : 
     970             : // compiler-dispatcher.cc
     971          84 : DEFINE_BOOL(parallel_compile_tasks, false, "enable parallel compile tasks")
     972          84 : DEFINE_BOOL(compiler_dispatcher, false, "enable compiler dispatcher")
     973      171179 : DEFINE_IMPLICATION(parallel_compile_tasks, compiler_dispatcher)
     974          84 : DEFINE_BOOL(trace_compiler_dispatcher, false,
     975             :             "trace compiler dispatcher activity")
     976             : 
     977             : // cpu-profiler.cc
     978          84 : DEFINE_INT(cpu_profiler_sampling_interval, 1000,
     979             :            "CPU profiler sampling interval in microseconds")
     980             : 
     981             : // Array abuse tracing
     982          84 : DEFINE_BOOL(trace_js_array_abuse, false,
     983             :             "trace out-of-bounds accesses to JS arrays")
     984          84 : DEFINE_BOOL(trace_external_array_abuse, false,
     985             :             "trace out-of-bounds-accesses to external arrays")
     986          84 : DEFINE_BOOL(trace_array_abuse, false,
     987             :             "trace out-of-bounds accesses to all arrays")
     988      171179 : DEFINE_IMPLICATION(trace_array_abuse, trace_js_array_abuse)
     989      171179 : DEFINE_IMPLICATION(trace_array_abuse, trace_external_array_abuse)
     990             : 
     991             : // debugger
     992          84 : DEFINE_BOOL(
     993             :     trace_side_effect_free_debug_evaluate, false,
     994             :     "print debug messages for side-effect-free debug-evaluate for testing")
     995          84 : DEFINE_BOOL(hard_abort, true, "abort by crashing")
     996             : 
     997             : // inspector
     998          84 : DEFINE_BOOL(expose_inspector_scripts, false,
     999             :             "expose injected-script-source.js for debugging")
    1000             : 
    1001             : // execution.cc
    1002          84 : DEFINE_INT(stack_size, V8_DEFAULT_STACK_SIZE_KB,
    1003             :            "default size of stack region v8 is allowed to use (in kBytes)")
    1004             : 
    1005             : // frames.cc
    1006          84 : DEFINE_INT(max_stack_trace_source_length, 300,
    1007             :            "maximum length of function source code printed in a stack trace.")
    1008             : 
    1009             : // execution.cc, messages.cc
    1010          84 : DEFINE_BOOL(clear_exceptions_on_js_entry, false,
    1011             :             "clear pending exceptions when entering JavaScript")
    1012             : 
    1013             : // counters.cc
    1014          84 : DEFINE_INT(histogram_interval, 600000,
    1015             :            "time interval in ms for aggregating memory histograms")
    1016             : 
    1017             : // heap-snapshot-generator.cc
    1018          84 : DEFINE_BOOL(heap_profiler_trace_objects, false,
    1019             :             "Dump heap object allocations/movements/size_updates")
    1020          84 : DEFINE_BOOL(heap_profiler_use_embedder_graph, true,
    1021             :             "Use the new EmbedderGraph API to get embedder nodes")
    1022          84 : DEFINE_INT(heap_snapshot_string_limit, 1024,
    1023             :            "truncate strings to this length in the heap snapshot")
    1024             : 
    1025             : // sampling-heap-profiler.cc
    1026          84 : DEFINE_BOOL(sampling_heap_profiler_suppress_randomness, false,
    1027             :             "Use constant sample intervals to eliminate test flakiness")
    1028             : 
    1029             : // v8.cc
    1030          84 : DEFINE_BOOL(use_idle_notification, true,
    1031             :             "Use idle notification to reduce memory footprint.")
    1032             : // ic.cc
    1033          84 : DEFINE_BOOL(trace_ic, false,
    1034             :             "trace inline cache state transitions for tools/ic-processor")
    1035      171179 : DEFINE_IMPLICATION(trace_ic, log_code)
    1036      171179 : DEFINE_GENERIC_IMPLICATION(
    1037             :     trace_ic, TracingFlags::ic_stats.store(
    1038             :                   v8::tracing::TracingCategoryObserver::ENABLED_BY_NATIVE))
    1039             : DEFINE_BOOL_READONLY(track_constant_fields, true,
    1040             :                      "enable constant field tracking")
    1041             : DEFINE_BOOL_READONLY(modify_map_inplace, true, "enable in-place map updates")
    1042             : DEFINE_BOOL_READONLY(fast_map_update, false,
    1043             :                      "enable fast map update by caching the migration target")
    1044          84 : DEFINE_INT(max_polymorphic_map_count, 4,
    1045             :            "maximum number of maps to track in POLYMORPHIC state")
    1046             : 
    1047             : // macro-assembler-ia32.cc
    1048          84 : DEFINE_BOOL(native_code_counters, false,
    1049             :             "generate extra code for manipulating stats counters")
    1050             : 
    1051             : // objects.cc
    1052          84 : DEFINE_BOOL(thin_strings, true, "Enable ThinString support")
    1053          84 : DEFINE_BOOL(trace_prototype_users, false,
    1054             :             "Trace updates to prototype user tracking")
    1055          84 : DEFINE_BOOL(use_verbose_printer, true, "allows verbose printing")
    1056          84 : DEFINE_BOOL(trace_for_in_enumerate, false, "Trace for-in enumerate slow-paths")
    1057          84 : DEFINE_BOOL(trace_maps, false, "trace map creation")
    1058          84 : DEFINE_BOOL(trace_maps_details, true, "also log map details")
    1059      171179 : DEFINE_IMPLICATION(trace_maps, log_code)
    1060             : 
    1061             : // parser.cc
    1062          84 : DEFINE_BOOL(allow_natives_syntax, false, "allow natives syntax")
    1063          84 : DEFINE_BOOL(parse_only, false, "only parse the sources")
    1064             : 
    1065             : // simulator-arm.cc, simulator-arm64.cc and simulator-mips.cc
    1066          84 : DEFINE_BOOL(trace_sim, false, "Trace simulator execution")
    1067          84 : DEFINE_BOOL(debug_sim, false, "Enable debugging the simulator")
    1068          84 : DEFINE_BOOL(check_icache, false,
    1069             :             "Check icache flushes in ARM and MIPS simulator")
    1070          84 : DEFINE_INT(stop_sim_at, 0, "Simulator stop after x number of instructions")
    1071             : #if defined(V8_TARGET_ARCH_ARM64) || defined(V8_TARGET_ARCH_MIPS64) || \
    1072             :     defined(V8_TARGET_ARCH_PPC64)
    1073             : DEFINE_INT(sim_stack_alignment, 16,
    1074             :            "Stack alignment in bytes in simulator. This must be a power of two "
    1075             :            "and it must be at least 16. 16 is default.")
    1076             : #else
    1077          84 : DEFINE_INT(sim_stack_alignment, 8,
    1078             :            "Stack alingment in bytes in simulator (4 or 8, 8 is default)")
    1079             : #endif
    1080          84 : DEFINE_INT(sim_stack_size, 2 * MB / KB,
    1081             :            "Stack size of the ARM64, MIPS64 and PPC64 simulator "
    1082             :            "in kBytes (default is 2 MB)")
    1083          84 : DEFINE_BOOL(log_colour, ENABLE_LOG_COLOUR,
    1084             :             "When logging, try to use coloured output.")
    1085          84 : DEFINE_BOOL(ignore_asm_unimplemented_break, false,
    1086             :             "Don't break for ASM_UNIMPLEMENTED_BREAK macros.")
    1087          84 : DEFINE_BOOL(trace_sim_messages, false,
    1088             :             "Trace simulator debug messages. Implied by --trace-sim.")
    1089             : 
    1090             : // isolate.cc
    1091          84 : DEFINE_BOOL(async_stack_traces, true,
    1092             :             "include async stack traces in Error.stack")
    1093      171179 : DEFINE_IMPLICATION(async_stack_traces, harmony_await_optimization)
    1094          84 : DEFINE_BOOL(stack_trace_on_illegal, false,
    1095             :             "print stack trace when an illegal exception is thrown")
    1096          84 : DEFINE_BOOL(abort_on_uncaught_exception, false,
    1097             :             "abort program (dump core) when an uncaught exception is thrown")
    1098             : // TODO(jgruber,machenbach): Rename to --correctness-fuzzer-suppressions.
    1099          84 : DEFINE_BOOL(abort_on_stack_or_string_length_overflow, false,
    1100             :             "Abort program when the stack overflows or a string exceeds "
    1101             :             "maximum length (as opposed to throwing RangeError). This is "
    1102             :             "useful for fuzzing where the spec behaviour would introduce "
    1103             :             "nondeterminism.")
    1104          84 : DEFINE_BOOL(randomize_hashes, true,
    1105             :             "randomize hashes to avoid predictable hash collisions "
    1106             :             "(with snapshots this option cannot override the baked-in seed)")
    1107          84 : DEFINE_BOOL(rehash_snapshot, true,
    1108             :             "rehash strings from the snapshot to override the baked-in seed")
    1109          84 : DEFINE_UINT64(hash_seed, 0,
    1110             :               "Fixed seed to use to hash property keys (0 means random)"
    1111             :               "(with snapshots this option cannot override the baked-in seed)")
    1112          84 : DEFINE_INT(random_seed, 0,
    1113             :            "Default seed for initializing random generator "
    1114             :            "(0, the default, means to use system random).")
    1115          84 : DEFINE_INT(fuzzer_random_seed, 0,
    1116             :            "Default seed for initializing fuzzer random generator "
    1117             :            "(0, the default, means to use v8's random number generator seed).")
    1118          84 : DEFINE_BOOL(trace_rail, false, "trace RAIL mode")
    1119          84 : DEFINE_BOOL(print_all_exceptions, false,
    1120             :             "print exception object and stack trace on each thrown exception")
    1121          84 : DEFINE_BOOL(
    1122             :     detailed_error_stack_trace, false,
    1123             :     "includes arguments for each function call in the error stack frames array")
    1124             : 
    1125             : // runtime.cc
    1126          84 : DEFINE_BOOL(runtime_call_stats, false, "report runtime call counts and times")
    1127      171179 : DEFINE_GENERIC_IMPLICATION(
    1128             :     runtime_call_stats,
    1129             :     TracingFlags::runtime_stats.store(
    1130             :         v8::tracing::TracingCategoryObserver::ENABLED_BY_NATIVE))
    1131             : 
    1132             : // snapshot-common.cc
    1133             : #ifdef V8_EMBEDDED_BUILTINS
    1134             : #define V8_EMBEDDED_BUILTINS_BOOL true
    1135             : #else
    1136             : #define V8_EMBEDDED_BUILTINS_BOOL false
    1137             : #endif
    1138             : DEFINE_BOOL_READONLY(embedded_builtins, V8_EMBEDDED_BUILTINS_BOOL,
    1139             :                      "Embed builtin code into the binary.")
    1140          84 : DEFINE_BOOL(profile_deserialization, false,
    1141             :             "Print the time it takes to deserialize the snapshot.")
    1142          84 : DEFINE_BOOL(serialization_statistics, false,
    1143             :             "Collect statistics on serialized objects.")
    1144          84 : DEFINE_UINT(serialization_chunk_size, 4096,
    1145             :             "Custom size for serialization chunks")
    1146             : 
    1147             : // Regexp
    1148          84 : DEFINE_BOOL(regexp_optimization, true, "generate optimized regexp code")
    1149          84 : DEFINE_BOOL(regexp_mode_modifiers, false, "enable inline flags in regexp.")
    1150          84 : DEFINE_BOOL(regexp_interpret_all, false,  "interpret all regexp code")
    1151             : 
    1152             : // Testing flags test/cctest/test-{flags,api,serialization}.cc
    1153          84 : DEFINE_BOOL(testing_bool_flag, true, "testing_bool_flag")
    1154          84 : DEFINE_MAYBE_BOOL(testing_maybe_bool_flag, "testing_maybe_bool_flag")
    1155          84 : DEFINE_INT(testing_int_flag, 13, "testing_int_flag")
    1156          84 : DEFINE_FLOAT(testing_float_flag, 2.5, "float-flag")
    1157          84 : DEFINE_STRING(testing_string_flag, "Hello, world!", "string-flag")
    1158          84 : DEFINE_INT(testing_prng_seed, 42, "Seed used for threading test randomness")
    1159             : 
    1160             : // mksnapshot.cc
    1161          84 : DEFINE_STRING(embedded_src, nullptr,
    1162             :               "Path for the generated embedded data file. (mksnapshot only)")
    1163          84 : DEFINE_STRING(
    1164             :     embedded_variant, nullptr,
    1165             :     "Label to disambiguate symbols in embedded data file. (mksnapshot only)")
    1166          84 : DEFINE_STRING(startup_src, nullptr,
    1167             :               "Write V8 startup as C++ src. (mksnapshot only)")
    1168          84 : DEFINE_STRING(startup_blob, nullptr,
    1169             :               "Write V8 startup blob file. (mksnapshot only)")
    1170             : 
    1171             : //
    1172             : // Minor mark compact collector flags.
    1173             : //
    1174             : #ifdef ENABLE_MINOR_MC
    1175          84 : DEFINE_BOOL(minor_mc_parallel_marking, true,
    1176             :             "use parallel marking for the young generation")
    1177          84 : DEFINE_BOOL(trace_minor_mc_parallel_marking, false,
    1178             :             "trace parallel marking for the young generation")
    1179          84 : DEFINE_BOOL(minor_mc, false, "perform young generation mark compact GCs")
    1180             : #endif  // ENABLE_MINOR_MC
    1181             : 
    1182             : //
    1183             : // Dev shell flags
    1184             : //
    1185             : 
    1186          84 : DEFINE_BOOL(help, false, "Print usage message, including flags, on console")
    1187          84 : DEFINE_BOOL(dump_counters, false, "Dump counters on exit")
    1188          84 : DEFINE_BOOL(dump_counters_nvp, false,
    1189             :             "Dump counters as name-value pairs on exit")
    1190          84 : DEFINE_BOOL(use_external_strings, false, "Use external strings for source code")
    1191             : 
    1192          84 : DEFINE_STRING(map_counters, "", "Map counters to a file")
    1193          84 : DEFINE_BOOL(mock_arraybuffer_allocator, false,
    1194             :             "Use a mock ArrayBuffer allocator for testing.")
    1195          84 : DEFINE_SIZE_T(mock_arraybuffer_allocator_limit, 0,
    1196             :               "Memory limit for mock ArrayBuffer allocator used to simulate "
    1197             :               "OOM for testing.")
    1198             : 
    1199             : //
    1200             : // Flags only available in non-Lite modes.
    1201             : //
    1202             : #undef FLAG
    1203             : #ifdef V8_LITE_MODE
    1204             : #define FLAG FLAG_READONLY
    1205             : #else
    1206             : #define FLAG FLAG_FULL
    1207             : #endif
    1208             : 
    1209          84 : DEFINE_BOOL(jitless, V8_LITE_BOOL,
    1210             :             "Disable runtime allocation of executable memory.")
    1211             : 
    1212             : // Jitless V8 has a few implications:
    1213             : #ifndef V8_LITE_MODE
    1214             : // Optimizations (i.e. jitting) are disabled.
    1215      171179 : DEFINE_NEG_IMPLICATION(jitless, opt)
    1216             : #endif
    1217             : // Field representation tracking is only used by TurboFan.
    1218      171179 : DEFINE_NEG_IMPLICATION(jitless, track_field_types)
    1219      171179 : DEFINE_NEG_IMPLICATION(jitless, track_heap_object_fields)
    1220             : // Regexps are interpreted.
    1221      171179 : DEFINE_IMPLICATION(jitless, regexp_interpret_all)
    1222             : // asm.js validation is disabled since it triggers wasm code generation.
    1223      171179 : DEFINE_NEG_IMPLICATION(jitless, validate_asm)
    1224             : // Wasm is put into interpreter-only mode. We repeat flag implications down
    1225             : // here to ensure they're applied correctly by setting the --jitless flag.
    1226      171179 : DEFINE_IMPLICATION(jitless, wasm_interpret_all)
    1227      171179 : DEFINE_NEG_IMPLICATION(jitless, asm_wasm_lazy_compilation)
    1228      171179 : DEFINE_NEG_IMPLICATION(jitless, wasm_lazy_compilation)
    1229             : // --jitless also implies --no-expose-wasm, see InitializeOncePerProcessImpl.
    1230             : 
    1231             : // Enable recompilation of function with optimized code.
    1232          84 : DEFINE_BOOL(opt, !V8_LITE_BOOL, "use adaptive optimizations")
    1233             : 
    1234             : // Enable use of inline caches to optimize object access operations.
    1235          84 : DEFINE_BOOL(use_ic, !V8_LITE_BOOL, "use inline caching")
    1236             : 
    1237             : // Favor memory over execution speed.
    1238          84 : DEFINE_BOOL(optimize_for_size, V8_LITE_BOOL,
    1239             :             "Enables optimizations which favor memory size over execution "
    1240             :             "speed")
    1241      171179 : DEFINE_VALUE_IMPLICATION(optimize_for_size, max_semi_space_size, 1)
    1242             : 
    1243             : //
    1244             : // GDB JIT integration flags.
    1245             : //
    1246             : #undef FLAG
    1247             : #ifdef ENABLE_GDB_JIT_INTERFACE
    1248             : #define FLAG FLAG_FULL
    1249             : #else
    1250             : #define FLAG FLAG_READONLY
    1251             : #endif
    1252             : 
    1253          84 : DEFINE_BOOL(gdbjit, false, "enable GDBJIT interface")
    1254          84 : DEFINE_BOOL(gdbjit_full, false, "enable GDBJIT interface for all code objects")
    1255          84 : DEFINE_BOOL(gdbjit_dump, false, "dump elf objects with debug info to disk")
    1256          84 : DEFINE_STRING(gdbjit_dump_filter, "",
    1257             :               "dump only objects containing this substring")
    1258             : 
    1259             : #ifdef ENABLE_GDB_JIT_INTERFACE
    1260      171179 : DEFINE_IMPLICATION(gdbjit_full, gdbjit)
    1261      171179 : DEFINE_IMPLICATION(gdbjit_dump, gdbjit)
    1262             : #endif
    1263      171179 : DEFINE_NEG_IMPLICATION(gdbjit, compact_code_space)
    1264             : 
    1265             : //
    1266             : // Debug only flags
    1267             : //
    1268             : #undef FLAG
    1269             : #ifdef DEBUG
    1270             : #define FLAG FLAG_FULL
    1271             : #else
    1272             : #define FLAG FLAG_READONLY
    1273             : #endif
    1274             : 
    1275             : // checks.cc
    1276             : #ifdef ENABLE_SLOW_DCHECKS
    1277             : DEFINE_BOOL(enable_slow_asserts, true,
    1278             :             "enable asserts that are slow to execute")
    1279             : #endif
    1280             : 
    1281             : // codegen-ia32.cc / codegen-arm.cc / macro-assembler-*.cc
    1282             : DEFINE_BOOL(print_ast, false, "print source AST")
    1283             : DEFINE_BOOL(trap_on_abort, false, "replace aborts by breakpoints")
    1284             : 
    1285             : // compiler.cc
    1286             : DEFINE_BOOL(print_builtin_scopes, false, "print scopes for builtins")
    1287             : DEFINE_BOOL(print_scopes, false, "print scopes")
    1288             : 
    1289             : // contexts.cc
    1290             : DEFINE_BOOL(trace_contexts, false, "trace contexts operations")
    1291             : 
    1292             : // heap.cc
    1293             : DEFINE_BOOL(gc_verbose, false, "print stuff during garbage collection")
    1294             : DEFINE_BOOL(code_stats, false, "report code statistics after GC")
    1295             : DEFINE_BOOL(print_handles, false, "report handles after GC")
    1296             : DEFINE_BOOL(check_handle_count, false,
    1297             :             "Check that there are not too many handles at GC")
    1298             : DEFINE_BOOL(print_global_handles, false, "report global handles after GC")
    1299             : 
    1300             : // TurboFan debug-only flags.
    1301             : DEFINE_BOOL(trace_turbo_escape, false, "enable tracing in escape analysis")
    1302             : 
    1303             : // objects.cc
    1304             : DEFINE_BOOL(trace_module_status, false,
    1305             :             "Trace status transitions of ECMAScript modules")
    1306             : DEFINE_BOOL(trace_normalization, false,
    1307             :             "prints when objects are turned into dictionaries.")
    1308             : 
    1309             : // runtime.cc
    1310             : DEFINE_BOOL(trace_lazy, false, "trace lazy compilation")
    1311             : 
    1312             : // spaces.cc
    1313             : DEFINE_BOOL(collect_heap_spill_statistics, false,
    1314             :             "report heap spill statistics along with heap_stats "
    1315             :             "(requires heap_stats)")
    1316             : DEFINE_BOOL(trace_isolates, false, "trace isolate state changes")
    1317             : 
    1318             : // Regexp
    1319             : DEFINE_BOOL(regexp_possessive_quantifier, false,
    1320             :             "enable possessive quantifier syntax for testing")
    1321             : DEFINE_BOOL(trace_regexp_bytecodes, false, "trace regexp bytecode execution")
    1322             : DEFINE_BOOL(trace_regexp_assembler, false,
    1323             :             "trace regexp macro assembler calls.")
    1324             : DEFINE_BOOL(trace_regexp_parser, false, "trace regexp parsing")
    1325             : 
    1326             : // Debugger
    1327             : DEFINE_BOOL(print_break_location, false, "print source location on debug break")
    1328             : 
    1329             : // wasm instance management
    1330             : DEFINE_DEBUG_BOOL(trace_wasm_instances, false,
    1331             :                   "trace creation and collection of wasm instances")
    1332             : 
    1333             : //
    1334             : // Logging and profiling flags
    1335             : //
    1336             : #undef FLAG
    1337             : #define FLAG FLAG_FULL
    1338             : 
    1339             : // log.cc
    1340          84 : DEFINE_BOOL(log, false,
    1341             :             "Minimal logging (no API, code, GC, suspect, or handles samples).")
    1342          84 : DEFINE_BOOL(log_all, false, "Log all events to the log file.")
    1343          84 : DEFINE_BOOL(log_api, false, "Log API events to the log file.")
    1344          84 : DEFINE_BOOL(log_code, false,
    1345             :             "Log code events to the log file without profiling.")
    1346          84 : DEFINE_BOOL(log_handles, false, "Log global handle events.")
    1347          84 : DEFINE_BOOL(log_suspect, false, "Log suspect operations.")
    1348          84 : DEFINE_BOOL(log_source_code, false, "Log source code.")
    1349          84 : DEFINE_BOOL(log_function_events, false,
    1350             :             "Log function events "
    1351             :             "(parse, compile, execute) separately.")
    1352          84 : DEFINE_BOOL(prof, false,
    1353             :             "Log statistical profiling information (implies --log-code).")
    1354             : 
    1355          84 : DEFINE_BOOL(detailed_line_info, false,
    1356             :             "Always generate detailed line information for CPU profiling.")
    1357             : 
    1358             : #if defined(ANDROID)
    1359             : // Phones and tablets have processors that are much slower than desktop
    1360             : // and laptop computers for which current heuristics are tuned.
    1361             : #define DEFAULT_PROF_SAMPLING_INTERVAL 5000
    1362             : #else
    1363             : #define DEFAULT_PROF_SAMPLING_INTERVAL 1000
    1364             : #endif
    1365          84 : DEFINE_INT(prof_sampling_interval, DEFAULT_PROF_SAMPLING_INTERVAL,
    1366             :            "Interval for --prof samples (in microseconds).")
    1367             : #undef DEFAULT_PROF_SAMPLING_INTERVAL
    1368             : 
    1369          84 : DEFINE_BOOL(prof_cpp, false, "Like --prof, but ignore generated code.")
    1370      171179 : DEFINE_IMPLICATION(prof, prof_cpp)
    1371          84 : DEFINE_BOOL(prof_browser_mode, true,
    1372             :             "Used with --prof, turns on browser-compatible mode for profiling.")
    1373          84 : DEFINE_STRING(logfile, "v8.log", "Specify the name of the log file.")
    1374          84 : DEFINE_BOOL(logfile_per_isolate, true, "Separate log files for each isolate.")
    1375          84 : DEFINE_BOOL(ll_prof, false, "Enable low-level linux profiler.")
    1376          84 : DEFINE_BOOL(perf_basic_prof, false,
    1377             :             "Enable perf linux profiler (basic support).")
    1378      171179 : DEFINE_NEG_IMPLICATION(perf_basic_prof, compact_code_space)
    1379          84 : DEFINE_BOOL(perf_basic_prof_only_functions, false,
    1380             :             "Only report function code ranges to perf (i.e. no stubs).")
    1381      171179 : DEFINE_IMPLICATION(perf_basic_prof_only_functions, perf_basic_prof)
    1382          84 : DEFINE_BOOL(perf_prof, false,
    1383             :             "Enable perf linux profiler (experimental annotate support).")
    1384      171179 : DEFINE_NEG_IMPLICATION(perf_prof, compact_code_space)
    1385             : // TODO(v8:8462) Remove implication once perf supports remapping.
    1386      171179 : DEFINE_NEG_IMPLICATION(perf_prof, write_protect_code_memory)
    1387      171179 : DEFINE_NEG_IMPLICATION(perf_prof, wasm_write_protect_code_memory)
    1388          84 : DEFINE_BOOL(perf_prof_unwinding_info, false,
    1389             :             "Enable unwinding info for perf linux profiler (experimental).")
    1390      171179 : DEFINE_IMPLICATION(perf_prof, perf_prof_unwinding_info)
    1391          84 : DEFINE_STRING(gc_fake_mmap, "/tmp/__v8_gc__",
    1392             :               "Specify the name of the file for fake gc mmap used in ll_prof")
    1393          84 : DEFINE_BOOL(log_internal_timer_events, false, "Time internal events.")
    1394          84 : DEFINE_BOOL(log_timer_events, false,
    1395             :             "Time events including external callbacks.")
    1396      171179 : DEFINE_IMPLICATION(log_timer_events, log_internal_timer_events)
    1397      171179 : DEFINE_IMPLICATION(log_internal_timer_events, prof)
    1398          84 : DEFINE_BOOL(log_instruction_stats, false, "Log AArch64 instruction statistics.")
    1399          84 : DEFINE_STRING(log_instruction_file, "arm64_inst.csv",
    1400             :               "AArch64 instruction statistics log file.")
    1401          84 : DEFINE_INT(log_instruction_period, 1 << 22,
    1402             :            "AArch64 instruction statistics logging period.")
    1403             : 
    1404          84 : DEFINE_BOOL(redirect_code_traces, false,
    1405             :             "output deopt information and disassembly into file "
    1406             :             "code-<pid>-<isolate id>.asm")
    1407          84 : DEFINE_STRING(redirect_code_traces_to, nullptr,
    1408             :               "output deopt information and disassembly into the given file")
    1409             : 
    1410          84 : DEFINE_BOOL(print_opt_source, false,
    1411             :             "print source code of optimized and inlined functions")
    1412             : 
    1413             : #ifdef V8_TARGET_ARCH_ARM
    1414             : // Unsupported on arm. See https://crbug.com/v8/8713.
    1415             : DEFINE_BOOL_READONLY(
    1416             :     interpreted_frames_native_stack, false,
    1417             :     "Show interpreted frames on the native stack (useful for external "
    1418             :     "profilers).")
    1419             : #else
    1420          84 : DEFINE_BOOL(interpreted_frames_native_stack, false,
    1421             :             "Show interpreted frames on the native stack (useful for external "
    1422             :             "profilers).")
    1423             : #endif
    1424             : 
    1425             : //
    1426             : // Disassembler only flags
    1427             : //
    1428             : #undef FLAG
    1429             : #ifdef ENABLE_DISASSEMBLER
    1430             : #define FLAG FLAG_FULL
    1431             : #else
    1432             : #define FLAG FLAG_READONLY
    1433             : #endif
    1434             : 
    1435             : // elements.cc
    1436             : DEFINE_BOOL(trace_elements_transitions, false, "trace elements transitions")
    1437             : 
    1438             : DEFINE_BOOL(trace_creation_allocation_sites, false,
    1439             :             "trace the creation of allocation sites")
    1440             : 
    1441             : // codegen-ia32.cc / codegen-arm.cc
    1442             : DEFINE_BOOL(print_code, false, "print generated code")
    1443             : DEFINE_BOOL(print_opt_code, false, "print optimized code")
    1444             : DEFINE_STRING(print_opt_code_filter, "*", "filter for printing optimized code")
    1445             : DEFINE_BOOL(print_code_verbose, false, "print more information for code")
    1446             : DEFINE_BOOL(print_builtin_code, false, "print generated code for builtins")
    1447             : DEFINE_STRING(print_builtin_code_filter, "*",
    1448             :               "filter for printing builtin code")
    1449             : DEFINE_BOOL(print_builtin_size, false, "print code size for builtins")
    1450             : 
    1451             : #ifdef ENABLE_DISASSEMBLER
    1452             : DEFINE_BOOL(sodium, false,
    1453             :             "print generated code output suitable for use with "
    1454             :             "the Sodium code viewer")
    1455             : 
    1456             : DEFINE_IMPLICATION(sodium, print_code)
    1457             : DEFINE_IMPLICATION(sodium, print_opt_code)
    1458             : DEFINE_IMPLICATION(sodium, code_comments)
    1459             : 
    1460             : DEFINE_BOOL(print_all_code, false, "enable all flags related to printing code")
    1461             : DEFINE_IMPLICATION(print_all_code, print_code)
    1462             : DEFINE_IMPLICATION(print_all_code, print_opt_code)
    1463             : DEFINE_IMPLICATION(print_all_code, print_code_verbose)
    1464             : DEFINE_IMPLICATION(print_all_code, print_builtin_code)
    1465             : DEFINE_IMPLICATION(print_all_code, code_comments)
    1466             : #endif
    1467             : 
    1468             : #undef FLAG
    1469             : #define FLAG FLAG_FULL
    1470             : 
    1471             : //
    1472             : // Predictable mode related flags.
    1473             : //
    1474             : 
    1475          84 : DEFINE_BOOL(predictable, false, "enable predictable mode")
    1476      171179 : DEFINE_IMPLICATION(predictable, single_threaded)
    1477      171179 : DEFINE_NEG_IMPLICATION(predictable, memory_reducer)
    1478      171179 : DEFINE_VALUE_IMPLICATION(single_threaded, wasm_num_compilation_tasks, 0)
    1479      171179 : DEFINE_NEG_IMPLICATION(single_threaded, wasm_async_compilation)
    1480             : 
    1481          84 : DEFINE_BOOL(predictable_gc_schedule, false,
    1482             :             "Predictable garbage collection schedule. Fixes heap growing, "
    1483             :             "idle, and memory reducing behavior.")
    1484      171179 : DEFINE_VALUE_IMPLICATION(predictable_gc_schedule, min_semi_space_size, 4)
    1485      171179 : DEFINE_VALUE_IMPLICATION(predictable_gc_schedule, max_semi_space_size, 4)
    1486      171179 : DEFINE_VALUE_IMPLICATION(predictable_gc_schedule, heap_growing_percent, 30)
    1487      171179 : DEFINE_NEG_IMPLICATION(predictable_gc_schedule, idle_time_scavenge)
    1488      171179 : DEFINE_NEG_IMPLICATION(predictable_gc_schedule, memory_reducer)
    1489             : 
    1490             : //
    1491             : // Threading related flags.
    1492             : //
    1493             : 
    1494          84 : DEFINE_BOOL(single_threaded, false, "disable the use of background tasks")
    1495      171179 : DEFINE_IMPLICATION(single_threaded, single_threaded_gc)
    1496      171179 : DEFINE_NEG_IMPLICATION(single_threaded, concurrent_recompilation)
    1497      171179 : DEFINE_NEG_IMPLICATION(single_threaded, compiler_dispatcher)
    1498             : 
    1499             : //
    1500             : // Parallel and concurrent GC (Orinoco) related flags.
    1501             : //
    1502          84 : DEFINE_BOOL(single_threaded_gc, false, "disable the use of background gc tasks")
    1503      171179 : DEFINE_NEG_IMPLICATION(single_threaded_gc, concurrent_marking)
    1504      171179 : DEFINE_NEG_IMPLICATION(single_threaded_gc, concurrent_sweeping)
    1505      171179 : DEFINE_NEG_IMPLICATION(single_threaded_gc, parallel_compaction)
    1506      171179 : DEFINE_NEG_IMPLICATION(single_threaded_gc, parallel_marking)
    1507      171179 : DEFINE_NEG_IMPLICATION(single_threaded_gc, parallel_pointer_update)
    1508      171179 : DEFINE_NEG_IMPLICATION(single_threaded_gc, parallel_scavenge)
    1509      171179 : DEFINE_NEG_IMPLICATION(single_threaded_gc, concurrent_store_buffer)
    1510             : #ifdef ENABLE_MINOR_MC
    1511      171179 : DEFINE_NEG_IMPLICATION(single_threaded_gc, minor_mc_parallel_marking)
    1512             : #endif  // ENABLE_MINOR_MC
    1513      171179 : DEFINE_NEG_IMPLICATION(single_threaded_gc, concurrent_array_buffer_freeing)
    1514             : 
    1515             : #undef FLAG
    1516             : 
    1517             : #ifdef VERIFY_PREDICTABLE
    1518             : #define FLAG FLAG_FULL
    1519             : #else
    1520             : #define FLAG FLAG_READONLY
    1521             : #endif
    1522             : 
    1523             : DEFINE_BOOL(verify_predictable, false,
    1524             :             "this mode is used for checking that V8 behaves predictably")
    1525             : DEFINE_INT(dump_allocations_digest_at_alloc, -1,
    1526             :            "dump allocations digest each n-th allocation")
    1527             : 
    1528             : //
    1529             : // Read-only flags
    1530             : //
    1531             : #undef FLAG
    1532             : #define FLAG FLAG_READONLY
    1533             : 
    1534             : // assembler.h
    1535             : DEFINE_BOOL(enable_embedded_constant_pool, V8_EMBEDDED_CONSTANT_POOL,
    1536             :             "enable use of embedded constant pools (PPC only)")
    1537             : 
    1538             : DEFINE_BOOL(unbox_double_fields, V8_DOUBLE_FIELDS_UNBOXING,
    1539             :             "enable in-object double fields unboxing (64-bit only)")
    1540             : DEFINE_IMPLICATION(unbox_double_fields, track_double_fields)
    1541             : 
    1542             : DEFINE_BOOL(raw_heap_snapshots, V8_ENABLE_RAW_HEAP_SNAPSHOTS_BOOL,
    1543             :             "enable raw heap snapshots contain garbage collection internals")
    1544             : 
    1545             : DEFINE_BOOL(lite_mode, V8_LITE_BOOL,
    1546             :             "enables trade-off of performance for memory savings "
    1547             :             "(Lite mode only)")
    1548             : 
    1549             : // Cleanup...
    1550             : #undef FLAG_FULL
    1551             : #undef FLAG_READONLY
    1552             : #undef FLAG
    1553             : #undef FLAG_ALIAS
    1554             : 
    1555             : #undef DEFINE_BOOL
    1556             : #undef DEFINE_MAYBE_BOOL
    1557             : #undef DEFINE_DEBUG_BOOL
    1558             : #undef DEFINE_INT
    1559             : #undef DEFINE_STRING
    1560             : #undef DEFINE_FLOAT
    1561             : #undef DEFINE_IMPLICATION
    1562             : #undef DEFINE_NEG_IMPLICATION
    1563             : #undef DEFINE_NEG_VALUE_IMPLICATION
    1564             : #undef DEFINE_VALUE_IMPLICATION
    1565             : #undef DEFINE_GENERIC_IMPLICATION
    1566             : #undef DEFINE_ALIAS_BOOL
    1567             : #undef DEFINE_ALIAS_INT
    1568             : #undef DEFINE_ALIAS_STRING
    1569             : #undef DEFINE_ALIAS_FLOAT
    1570             : 
    1571             : #undef FLAG_MODE_DECLARE
    1572             : #undef FLAG_MODE_DEFINE
    1573             : #undef FLAG_MODE_DEFINE_DEFAULTS
    1574             : #undef FLAG_MODE_META
    1575             : #undef FLAG_MODE_DEFINE_IMPLICATIONS
    1576             : #undef FLAG_MODE_APPLY
    1577             : 
    1578             : #undef COMMA

Generated by: LCOV version 1.10