LCOV - code coverage report
Current view: top level - src - flags.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 224 246 91.1 %
Date: 2017-04-26 Functions: 16 16 100.0 %

          Line data    Source code
       1             : // Copyright 2006-2008 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             : #include "src/flags.h"
       6             : 
       7             : #include <cctype>
       8             : #include <cstdlib>
       9             : #include <sstream>
      10             : 
      11             : #include "src/allocation.h"
      12             : #include "src/assembler.h"
      13             : #include "src/base/functional.h"
      14             : #include "src/base/platform/platform.h"
      15             : #include "src/list-inl.h"
      16             : #include "src/ostreams.h"
      17             : #include "src/utils.h"
      18             : #include "src/wasm/wasm-limits.h"
      19             : 
      20             : namespace v8 {
      21             : namespace internal {
      22             : 
      23             : // Define all of our flags.
      24             : #define FLAG_MODE_DEFINE
      25             : #include "src/flag-definitions.h"  // NOLINT(build/include)
      26             : 
      27             : // Define all of our flags default values.
      28             : #define FLAG_MODE_DEFINE_DEFAULTS
      29             : #include "src/flag-definitions.h"  // NOLINT(build/include)
      30             : 
      31             : namespace {
      32             : 
      33             : // This structure represents a single entry in the flag system, with a pointer
      34             : // to the actual flag, default value, comment, etc.  This is designed to be POD
      35             : // initialized as to avoid requiring static constructors.
      36             : struct Flag {
      37             :   enum FlagType {
      38             :     TYPE_BOOL,
      39             :     TYPE_MAYBE_BOOL,
      40             :     TYPE_INT,
      41             :     TYPE_UINT,
      42             :     TYPE_FLOAT,
      43             :     TYPE_STRING,
      44             :     TYPE_ARGS
      45             :   };
      46             : 
      47             :   FlagType type_;           // What type of flag, bool, int, or string.
      48             :   const char* name_;        // Name of the flag, ex "my_flag".
      49             :   void* valptr_;            // Pointer to the global flag variable.
      50             :   const void* defptr_;      // Pointer to the default value.
      51             :   const char* cmt_;         // A comment about the flags purpose.
      52             :   bool owns_ptr_;           // Does the flag own its string value?
      53             : 
      54             :   FlagType type() const { return type_; }
      55             : 
      56             :   const char* name() const { return name_; }
      57             : 
      58             :   const char* comment() const { return cmt_; }
      59             : 
      60             :   bool* bool_variable() const {
      61             :     DCHECK(type_ == TYPE_BOOL);
      62             :     return reinterpret_cast<bool*>(valptr_);
      63             :   }
      64             : 
      65             :   MaybeBoolFlag* maybe_bool_variable() const {
      66             :     DCHECK(type_ == TYPE_MAYBE_BOOL);
      67             :     return reinterpret_cast<MaybeBoolFlag*>(valptr_);
      68             :   }
      69             : 
      70             :   int* int_variable() const {
      71             :     DCHECK(type_ == TYPE_INT);
      72             :     return reinterpret_cast<int*>(valptr_);
      73             :   }
      74             : 
      75             :   unsigned int* uint_variable() const {
      76             :     DCHECK(type_ == TYPE_UINT);
      77             :     return reinterpret_cast<unsigned int*>(valptr_);
      78             :   }
      79             : 
      80             :   double* float_variable() const {
      81             :     DCHECK(type_ == TYPE_FLOAT);
      82             :     return reinterpret_cast<double*>(valptr_);
      83             :   }
      84             : 
      85             :   const char* string_value() const {
      86             :     DCHECK(type_ == TYPE_STRING);
      87     5297033 :     return *reinterpret_cast<const char**>(valptr_);
      88             :   }
      89             : 
      90             :   void set_string_value(const char* value, bool owns_ptr) {
      91             :     DCHECK(type_ == TYPE_STRING);
      92             :     const char** ptr = reinterpret_cast<const char**>(valptr_);
      93      912800 :     if (owns_ptr_ && *ptr != NULL) DeleteArray(*ptr);
      94      912800 :     *ptr = value;
      95      912800 :     owns_ptr_ = owns_ptr;
      96             :   }
      97             : 
      98             :   JSArguments* args_variable() const {
      99             :     DCHECK(type_ == TYPE_ARGS);
     100             :     return reinterpret_cast<JSArguments*>(valptr_);
     101             :   }
     102             : 
     103             :   bool bool_default() const {
     104             :     DCHECK(type_ == TYPE_BOOL);
     105    84811630 :     return *reinterpret_cast<const bool*>(defptr_);
     106             :   }
     107             : 
     108             :   int int_default() const {
     109             :     DCHECK(type_ == TYPE_INT);
     110    12423112 :     return *reinterpret_cast<const int*>(defptr_);
     111             :   }
     112             : 
     113             :   unsigned int uint_default() const {
     114             :     DCHECK(type_ == TYPE_UINT);
     115      716718 :     return *reinterpret_cast<const unsigned int*>(defptr_);
     116             :   }
     117             : 
     118             :   double float_default() const {
     119             :     DCHECK(type_ == TYPE_FLOAT);
     120      238906 :     return *reinterpret_cast<const double*>(defptr_);
     121             :   }
     122             : 
     123             :   const char* string_default() const {
     124             :     DCHECK(type_ == TYPE_STRING);
     125     5733744 :     return *reinterpret_cast<const char* const *>(defptr_);
     126             :   }
     127             : 
     128             :   JSArguments args_default() const {
     129             :     DCHECK(type_ == TYPE_ARGS);
     130       32655 :     return *reinterpret_cast<const JSArguments*>(defptr_);
     131             :   }
     132             : 
     133             :   // Compare this flag's current value against the default.
     134   272457571 :   bool IsDefault() const {
     135    91369193 :     switch (type_) {
     136             :       case TYPE_BOOL:
     137   146438210 :         return *bool_variable() == bool_default();
     138             :       case TYPE_MAYBE_BOOL:
     139     1443757 :         return maybe_bool_variable()->has_value == false;
     140             :       case TYPE_INT:
     141    21450104 :         return *int_variable() == int_default();
     142             :       case TYPE_UINT:
     143     1237506 :         return *uint_variable() == uint_default();
     144             :       case TYPE_FLOAT:
     145      412502 :         return *float_variable() == float_default();
     146             :       case TYPE_STRING: {
     147             :         const char* str1 = string_value();
     148             :         const char* str2 = string_default();
     149     4950024 :         if (str2 == NULL) return str1 == NULL;
     150     2681263 :         if (str1 == NULL) return str2 == NULL;
     151     2681263 :         return strcmp(str1, str2) == 0;
     152             :       }
     153             :       case TYPE_ARGS:
     154      206251 :         return args_variable()->argc == 0;
     155             :     }
     156           0 :     UNREACHABLE();
     157             :     return true;
     158             :   }
     159             : 
     160             :   // Set a flag back to it's default value.
     161    29716050 :   void Reset() {
     162    14466165 :     switch (type_) {
     163             :       case TYPE_BOOL:
     164    11592525 :         *bool_variable() = bool_default();
     165    11592525 :         break;
     166             :       case TYPE_MAYBE_BOOL:
     167      228585 :         *maybe_bool_variable() = MaybeBoolFlag::Create(false, false);
     168      228585 :         break;
     169             :       case TYPE_INT:
     170     1698060 :         *int_variable() = int_default();
     171     1698060 :         break;
     172             :       case TYPE_UINT:
     173       97965 :         *uint_variable() = uint_default();
     174       97965 :         break;
     175             :       case TYPE_FLOAT:
     176       32655 :         *float_variable() = float_default();
     177       32655 :         break;
     178             :       case TYPE_STRING:
     179             :         set_string_value(string_default(), false);
     180             :         break;
     181             :       case TYPE_ARGS:
     182       32655 :         *args_variable() = args_default();
     183       32655 :         break;
     184             :     }
     185    14466165 :   }
     186             : };
     187             : 
     188             : Flag flags[] = {
     189             : #define FLAG_MODE_META
     190             : #include "src/flag-definitions.h"  // NOLINT(build/include)
     191             : };
     192             : 
     193             : const size_t num_flags = sizeof(flags) / sizeof(*flags);
     194             : 
     195             : }  // namespace
     196             : 
     197             : 
     198        3136 : static const char* Type2String(Flag::FlagType type) {
     199        3136 :   switch (type) {
     200             :     case Flag::TYPE_BOOL: return "bool";
     201          49 :     case Flag::TYPE_MAYBE_BOOL: return "maybe_bool";
     202         378 :     case Flag::TYPE_INT: return "int";
     203             :     case Flag::TYPE_UINT:
     204          21 :       return "uint";
     205          21 :     case Flag::TYPE_FLOAT: return "float";
     206         175 :     case Flag::TYPE_STRING: return "string";
     207           7 :     case Flag::TYPE_ARGS: return "arguments";
     208             :   }
     209           0 :   UNREACHABLE();
     210             :   return NULL;
     211             : }
     212             : 
     213             : 
     214     4284142 : std::ostream& operator<<(std::ostream& os, const Flag& flag) {  // NOLINT
     215     2142071 :   switch (flag.type()) {
     216             :     case Flag::TYPE_BOOL:
     217     1487961 :       os << (*flag.bool_variable() ? "true" : "false");
     218     1487961 :       break;
     219             :     case Flag::TYPE_MAYBE_BOOL:
     220             :       os << (flag.maybe_bool_variable()->has_value
     221             :                  ? (flag.maybe_bool_variable()->value ? "true" : "false")
     222          87 :                  : "unset");
     223          87 :       break;
     224             :     case Flag::TYPE_INT:
     225      306979 :       os << *flag.int_variable();
     226      306979 :       break;
     227             :     case Flag::TYPE_UINT:
     228          21 :       os << *flag.uint_variable();
     229             :       break;
     230             :     case Flag::TYPE_FLOAT:
     231           7 :       os << *flag.float_variable();
     232             :       break;
     233             :     case Flag::TYPE_STRING: {
     234             :       const char* str = flag.string_value();
     235      347009 :       os << (str ? str : "NULL");
     236      347009 :       break;
     237             :     }
     238             :     case Flag::TYPE_ARGS: {
     239           7 :       JSArguments args = *flag.args_variable();
     240           7 :       if (args.argc > 0) {
     241           0 :         os << args[0];
     242           0 :         for (int i = 1; i < args.argc; i++) {
     243           0 :           os << args[i];
     244             :         }
     245             :       }
     246             :       break;
     247             :     }
     248             :   }
     249     2142071 :   return os;
     250             : }
     251             : 
     252             : 
     253             : // static
     254          47 : List<const char*>* FlagList::argv() {
     255             :   List<const char*>* args = new List<const char*>(8);
     256           0 :   Flag* args_flag = NULL;
     257       20868 :   for (size_t i = 0; i < num_flags; ++i) {
     258       22043 :     Flag* f = &flags[i];
     259       20821 :     if (!f->IsDefault()) {
     260         329 :       if (f->type() == Flag::TYPE_ARGS) {
     261             :         DCHECK(args_flag == NULL);
     262             :         args_flag = f;  // Must be last in arguments.
     263             :         continue;
     264             :       }
     265             :       {
     266         564 :         bool disabled = f->type() == Flag::TYPE_BOOL && !*f->bool_variable();
     267         329 :         std::ostringstream os;
     268         329 :         os << (disabled ? "--no" : "--") << f->name();
     269         658 :         args->Add(StrDup(os.str().c_str()));
     270             :       }
     271         329 :       if (f->type() != Flag::TYPE_BOOL) {
     272          94 :         std::ostringstream os;
     273          94 :         os << *f;
     274         188 :         args->Add(StrDup(os.str().c_str()));
     275             :       }
     276             :     }
     277             :   }
     278          47 :   if (args_flag != NULL) {
     279           0 :     std::ostringstream os;
     280           0 :     os << "--" << args_flag->name();
     281           0 :     args->Add(StrDup(os.str().c_str()));
     282           0 :     JSArguments jsargs = *args_flag->args_variable();
     283           0 :     for (int j = 0; j < jsargs.argc; j++) {
     284           0 :       args->Add(StrDup(jsargs[j]));
     285           0 :     }
     286             :   }
     287          47 :   return args;
     288             : }
     289             : 
     290             : 
     291             : inline char NormalizeChar(char ch) {
     292   358878397 :   return ch == '_' ? '-' : ch;
     293             : }
     294             : 
     295             : 
     296             : // Helper function to parse flags: Takes an argument arg and splits it into
     297             : // a flag name and flag value (or NULL if they are missing). is_bool is set
     298             : // if the arg started with "-no" or "--no". The buffer may be used to NUL-
     299             : // terminate the name, it must be large enough to hold any possible name.
     300      765327 : static void SplitArgument(const char* arg,
     301             :                           char* buffer,
     302             :                           int buffer_size,
     303             :                           const char** name,
     304             :                           const char** value,
     305             :                           bool* is_bool) {
     306      765327 :   *name = NULL;
     307      765327 :   *value = NULL;
     308      765327 :   *is_bool = false;
     309             : 
     310      765327 :   if (arg != NULL && *arg == '-') {
     311             :     // find the begin of the flag name
     312      632040 :     arg++;  // remove 1st '-'
     313      632040 :     if (*arg == '-') {
     314      630497 :       arg++;  // remove 2nd '-'
     315      630497 :       if (arg[0] == '\0') {
     316             :         const char* kJSArgumentsFlagName = "js_arguments";
     317          21 :         *name = kJSArgumentsFlagName;
     318      765348 :         return;
     319             :       }
     320             :     }
     321      632019 :     if (arg[0] == 'n' && arg[1] == 'o') {
     322      249195 :       arg += 2;  // remove "no"
     323      498390 :       if (NormalizeChar(arg[0]) == '-') arg++;  // remove dash after "no".
     324      249195 :       *is_bool = true;
     325             :     }
     326      632019 :     *name = arg;
     327             : 
     328             :     // find the end of the flag name
     329    11231654 :     while (*arg != '\0' && *arg != '=')
     330     9967616 :       arg++;
     331             : 
     332             :     // get the value if any
     333      632019 :     if (*arg == '=') {
     334             :       // make a copy so we can NUL-terminate flag name
     335      261710 :       size_t n = arg - *name;
     336      261710 :       CHECK(n < static_cast<size_t>(buffer_size));  // buffer is too small
     337             :       MemCopy(buffer, *name, n);
     338      261710 :       buffer[n] = '\0';
     339      261710 :       *name = buffer;
     340             :       // get the value
     341      261710 :       *value = arg + 1;
     342             :     }
     343             :   }
     344             : }
     345             : 
     346             : 
     347             : static bool EqualNames(const char* a, const char* b) {
     348   394384247 :   for (int i = 0; NormalizeChar(a[i]) == NormalizeChar(b[i]); i++) {
     349    36374339 :     if (a[i] == '\0') {
     350             :       return true;
     351             :     }
     352             :   }
     353             :   return false;
     354             : }
     355             : 
     356             : 
     357      632040 : static Flag* FindFlag(const char* name) {
     358   143572302 :   for (size_t i = 0; i < num_flags; ++i) {
     359   287119112 :     if (EqualNames(name, flags[i].name()))
     360             :       return &flags[i];
     361             :   }
     362             :   return NULL;
     363             : }
     364             : 
     365             : 
     366             : // static
     367      249385 : int FlagList::SetFlagsFromCommandLine(int* argc,
     368             :                                       char** argv,
     369             :                                       bool remove_flags) {
     370             :   int return_code = 0;
     371             :   // parse arguments
     372     1264055 :   for (int i = 1; i < *argc;) {
     373             :     int j = i;  // j > 0
     374      765327 :     const char* arg = argv[i++];
     375             : 
     376             :     // split arg into flag components
     377             :     char buffer[1*KB];
     378             :     const char* name;
     379             :     const char* value;
     380             :     bool is_bool;
     381      765327 :     SplitArgument(arg, buffer, sizeof buffer, &name, &value, &is_bool);
     382             : 
     383      765327 :     if (name != NULL) {
     384             :       // lookup the flag
     385     2489880 :       Flag* flag = FindFlag(name);
     386      632040 :       if (flag == NULL) {
     387       12746 :         if (remove_flags) {
     388             :           // We don't recognize this flag but since we're removing
     389             :           // the flags we recognize we assume that the remaining flags
     390             :           // will be processed somewhere else so this flag might make
     391             :           // sense there.
     392       12739 :           continue;
     393             :         } else {
     394             :           PrintF(stderr, "Error: unrecognized flag %s\n"
     395           7 :                  "Try --help for options\n", arg);
     396             :           return_code = j;
     397           7 :           break;
     398             :         }
     399             :       }
     400             : 
     401             :       // if we still need a flag value, use the next argument if available
     402      881251 :       if (flag->type() != Flag::TYPE_BOOL &&
     403      261923 :           flag->type() != Flag::TYPE_MAYBE_BOOL &&
     404      881182 :           flag->type() != Flag::TYPE_ARGS &&
     405      261888 :           value == NULL) {
     406         228 :         if (i < *argc) {
     407         207 :           value = argv[i++];
     408             :         }
     409         228 :         if (!value) {
     410             :           PrintF(stderr, "Error: missing value for flag %s of type %s\n"
     411             :                  "Try --help for options\n",
     412          21 :                  arg, Type2String(flag->type()));
     413             :           return_code = j;
     414          21 :           break;
     415             :         }
     416             :       }
     417             : 
     418             :       // set the flag
     419      619273 :       char* endp = const_cast<char*>("");  // *endp is only read
     420      619273 :       switch (flag->type()) {
     421             :         case Flag::TYPE_BOOL:
     422      357337 :           *flag->bool_variable() = !is_bool;
     423      357337 :           break;
     424             :         case Flag::TYPE_MAYBE_BOOL:
     425          68 :           *flag->maybe_bool_variable() = MaybeBoolFlag::Create(true, !is_bool);
     426          34 :           break;
     427             :         case Flag::TYPE_INT:
     428      132759 :           *flag->int_variable() = static_cast<int>(strtol(value, &endp, 10));
     429      132759 :           break;
     430             :         case Flag::TYPE_UINT: {
     431             :           // We do not use strtoul because it accepts negative numbers.
     432           0 :           int64_t val = static_cast<int64_t>(strtoll(value, &endp, 10));
     433           0 :           if (val < 0 || val > std::numeric_limits<unsigned int>::max()) {
     434             :             PrintF(stderr,
     435             :                    "Error: Value for flag %s of type %s is out of bounds "
     436             :                    "[0-%" PRIu64
     437             :                    "]\n"
     438             :                    "Try --help for options\n",
     439             :                    arg, Type2String(flag->type()),
     440             :                    static_cast<uint64_t>(
     441           0 :                        std::numeric_limits<unsigned int>::max()));
     442             :             return_code = j;
     443           0 :             break;
     444             :           }
     445           0 :           *flag->uint_variable() = static_cast<unsigned int>(val);
     446           0 :           break;
     447             :         }
     448             :         case Flag::TYPE_FLOAT:
     449          28 :           *flag->float_variable() = strtod(value, &endp);
     450          28 :           break;
     451             :         case Flag::TYPE_STRING:
     452      129080 :           flag->set_string_value(value ? StrDup(value) : NULL, true);
     453             :           break;
     454             :         case Flag::TYPE_ARGS: {
     455          35 :           int start_pos = (value == NULL) ? i : i - 1;
     456          35 :           int js_argc = *argc - start_pos;
     457          35 :           const char** js_argv = NewArray<const char*>(js_argc);
     458          35 :           if (value != NULL) {
     459           7 :             js_argv[0] = StrDup(value);
     460             :           }
     461          84 :           for (int k = i; k < *argc; k++) {
     462          49 :             js_argv[k - start_pos] = StrDup(argv[k]);
     463             :           }
     464          35 :           *flag->args_variable() = JSArguments::Create(js_argc, js_argv);
     465          35 :           i = *argc;  // Consume all arguments
     466          35 :           break;
     467             :         }
     468             :       }
     469             : 
     470             :       // handle errors
     471      619273 :       bool is_bool_type = flag->type() == Flag::TYPE_BOOL ||
     472             :           flag->type() == Flag::TYPE_MAYBE_BOOL;
     473     1238546 :       if ((is_bool_type && value != NULL) || (!is_bool_type && is_bool) ||
     474      619273 :           *endp != '\0') {
     475             :         PrintF(stderr, "Error: illegal value for flag %s of type %s\n"
     476             :                "Try --help for options\n",
     477          14 :                arg, Type2String(flag->type()));
     478          14 :         if (is_bool_type) {
     479             :           PrintF(stderr,
     480           0 :                  "To set or unset a boolean flag, use --flag or --no-flag.\n");
     481             :         }
     482             :         return_code = j;
     483             :         break;
     484             :       }
     485             : 
     486             :       // remove the flag & value from the command
     487      619259 :       if (remove_flags) {
     488      664672 :         while (j < i) {
     489      332368 :           argv[j++] = NULL;
     490             :         }
     491             :       }
     492             :     }
     493             :   }
     494             : 
     495             :   // shrink the argument list
     496      249385 :   if (remove_flags) {
     497             :     int j = 1;
     498      478394 :     for (int i = 1; i < *argc; i++) {
     499      478394 :       if (argv[i] != NULL)
     500      103396 :         argv[j++] = argv[i];
     501             :     }
     502       59508 :     *argc = j;
     503             :   }
     504             : 
     505      249385 :   if (FLAG_help) {
     506           0 :     PrintHelp();
     507           0 :     exit(0);
     508             :   }
     509             :   // parsed all flags successfully
     510      249385 :   return return_code;
     511             : }
     512             : 
     513             : 
     514      763351 : static char* SkipWhiteSpace(char* p) {
     515      763351 :   while (*p != '\0' && isspace(*p) != 0) p++;
     516      763351 :   return p;
     517             : }
     518             : 
     519             : 
     520      573528 : static char* SkipBlackSpace(char* p) {
     521      573528 :   while (*p != '\0' && isspace(*p) == 0) p++;
     522      573528 :   return p;
     523             : }
     524             : 
     525             : 
     526             : // static
     527      189823 : int FlagList::SetFlagsFromString(const char* str, int len) {
     528             :   // make a 0-terminated copy of str
     529      189823 :   ScopedVector<char> copy0(len + 1);
     530      189823 :   MemCopy(copy0.start(), str, len);
     531      189823 :   copy0[len] = '\0';
     532             : 
     533             :   // strip leading white space
     534      189823 :   char* copy = SkipWhiteSpace(copy0.start());
     535             : 
     536             :   // count the number of 'arguments'
     537      189823 :   int argc = 1;  // be compatible with SetFlagsFromCommandLine()
     538      476587 :   for (char* p = copy; *p != '\0'; argc++) {
     539      286764 :     p = SkipBlackSpace(p);
     540      286764 :     p = SkipWhiteSpace(p);
     541             :   }
     542             : 
     543             :   // allocate argument array
     544      189823 :   ScopedVector<char*> argv(argc);
     545             : 
     546             :   // split the flags string into arguments
     547      189823 :   argc = 1;  // be compatible with SetFlagsFromCommandLine()
     548      476587 :   for (char* p = copy; *p != '\0'; argc++) {
     549      573528 :     argv[argc] = p;
     550      286764 :     p = SkipBlackSpace(p);
     551      286764 :     if (*p != '\0') *p++ = '\0';  // 0-terminate argument
     552      286764 :     p = SkipWhiteSpace(p);
     553             :   }
     554             : 
     555             :   // set the flags
     556      189823 :   int result = SetFlagsFromCommandLine(&argc, argv.start(), false);
     557             : 
     558      189823 :   return result;
     559             : }
     560             : 
     561             : 
     562             : // static
     563       32655 : void FlagList::ResetAllFlags() {
     564    14498820 :   for (size_t i = 0; i < num_flags; ++i) {
     565    14466165 :     flags[i].Reset();
     566             :   }
     567       32655 : }
     568             : 
     569             : 
     570             : // static
     571           7 : void FlagList::PrintHelp() {
     572             :   CpuFeatures::Probe(false);
     573           7 :   CpuFeatures::PrintTarget();
     574           7 :   CpuFeatures::PrintFeatures();
     575             : 
     576           7 :   OFStream os(stdout);
     577           7 :   os << "Usage:\n"
     578           7 :      << "  shell [options] -e string\n"
     579           7 :      << "    execute string in V8\n"
     580           7 :      << "  shell [options] file1 file2 ... filek\n"
     581           7 :      << "    run JavaScript scripts in file1, file2, ..., filek\n"
     582           7 :      << "  shell [options]\n"
     583           7 :      << "  shell [options] --shell [file1 file2 ... filek]\n"
     584           7 :      << "    run an interactive JavaScript shell\n"
     585           7 :      << "  d8 [options] file1 file2 ... filek\n"
     586           7 :      << "  d8 [options]\n"
     587           7 :      << "  d8 [options] --shell [file1 file2 ... filek]\n"
     588           7 :      << "    run the new debugging shell\n\n"
     589           7 :      << "Options:\n";
     590        3108 :   for (size_t i = 0; i < num_flags; ++i) {
     591        6202 :     Flag* f = &flags[i];
     592        3101 :     os << "  --" << f->name() << " (" << f->comment() << ")\n"
     593        6202 :        << "        type: " << Type2String(f->type()) << "  default: " << *f
     594        3101 :        << "\n";
     595           7 :   }
     596           7 : }
     597             : 
     598             : 
     599             : static uint32_t flag_hash = 0;
     600             : 
     601             : 
     602      206204 : void ComputeFlagListHash() {
     603      206204 :   std::ostringstream modified_args_as_string;
     604             : #ifdef DEBUG
     605             :   modified_args_as_string << "debug";
     606             : #endif  // DEBUG
     607    91554576 :   for (size_t i = 0; i < num_flags; ++i) {
     608    91348372 :     Flag* current = &flags[i];
     609    91348372 :     if (!current->IsDefault()) {
     610             :       modified_args_as_string << i;
     611     2138876 :       modified_args_as_string << *current;
     612             :     }
     613             :   }
     614             :   std::string args(modified_args_as_string.str());
     615             :   flag_hash = static_cast<uint32_t>(
     616      618612 :       base::hash_range(args.c_str(), args.c_str() + args.length()));
     617      206204 : }
     618             : 
     619             : 
     620             : // static
     621      206204 : void FlagList::EnforceFlagImplications() {
     622             : #define FLAG_MODE_DEFINE_IMPLICATIONS
     623             : #include "src/flag-definitions.h"  // NOLINT(build/include)
     624             : #undef FLAG_MODE_DEFINE_IMPLICATIONS
     625      206204 :   ComputeFlagListHash();
     626      206204 : }
     627             : 
     628             : 
     629         961 : uint32_t FlagList::Hash() { return flag_hash; }
     630             : }  // namespace internal
     631             : }  // namespace v8

Generated by: LCOV version 1.10