[Interpreter] Support relevant FLAG_s in generate-bytecode-expectations.

test/cctest/interpreter/generate-bytecode-expectations.cc

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <cstring>
 #include <fstream>
 
 #include "test/cctest/interpreter/bytecode-expectations-printer.h"
 
 #include "include/libplatform/libplatform.h"
@@ skipping 14 matching lines @@
 
   ProgramOptions()
       : parsing_failed_(false),
         print_help_(false),
         read_raw_js_snippet_(false),
         read_from_stdin_(false),
         rebaseline_(false),
         wrap_(true),
         execute_(true),
         top_level_(false),
+        legacy_const_(false),
+        do_expressions_(false),
         const_pool_type_(
             BytecodeExpectationsPrinter::ConstantPoolType::kMixed) {}
 
   bool Validate() const;
   void UpdateFromHeader(std::istream& stream);   // NOLINT
   void PrintHeader(std::ostream& stream) const;  // NOLINT
 
   bool parsing_failed() const { return parsing_failed_; }
   bool print_help() const { return print_help_; }
   bool read_raw_js_snippet() const { return read_raw_js_snippet_; }
   bool read_from_stdin() const { return read_from_stdin_; }
   bool write_to_stdout() const {
     return output_filename_.empty() && !rebaseline_;
   }
   bool rebaseline() const { return rebaseline_; }
   bool wrap() const { return wrap_; }
   bool execute() const { return execute_; }
   bool top_level() const { return top_level_; }
+  bool legacy_const() const { return legacy_const_; }
+  bool do_expressions() const { return do_expressions_; }
   BytecodeExpectationsPrinter::ConstantPoolType const_pool_type() const {
     return const_pool_type_;
   }
   std::string input_filename() const { return input_filename_; }
   std::string output_filename() const { return output_filename_; }
   std::string test_function_name() const { return test_function_name_; }
 
  private:
   bool parsing_failed_;
   bool print_help_;
   bool read_raw_js_snippet_;
   bool read_from_stdin_;
   bool rebaseline_;
   bool wrap_;
   bool execute_;
   bool top_level_;
+  bool legacy_const_;
+  bool do_expressions_;
   BytecodeExpectationsPrinter::ConstantPoolType const_pool_type_;
   std::string input_filename_;
   std::string output_filename_;
   std::string test_function_name_;
 };
 
 class ArrayBufferAllocator final : public v8::ArrayBuffer::Allocator {
  public:
   void* Allocate(size_t length) override {
     void* data = AllocateUninitialized(length);
@@ skipping 73 matching lines @@
     } else if (strcmp(argv[i], "--stdin") == 0) {
       options.read_from_stdin_ = true;
     } else if (strcmp(argv[i], "--rebaseline") == 0) {
       options.rebaseline_ = true;
     } else if (strcmp(argv[i], "--no-wrap") == 0) {
       options.wrap_ = false;
     } else if (strcmp(argv[i], "--no-execute") == 0) {
       options.execute_ = false;
     } else if (strcmp(argv[i], "--top-level") == 0) {
       options.top_level_ = true;
+    } else if (strcmp(argv[i], "--legacy-const") == 0) {
+      options.legacy_const_ = true;
+    } else if (strcmp(argv[i], "--do-expressions") == 0) {
+      options.do_expressions_ = true;
     } else if (strncmp(argv[i], "--output=", 9) == 0) {
       options.output_filename_ = argv[i] + 9;
     } else if (strncmp(argv[i], "--test-function-name=", 21) == 0) {
       options.test_function_name_ = argv[i] + 21;
     } else if (strncmp(argv[i], "--", 2) != 0) {  // It doesn't start with --
       if (!options.input_filename_.empty()) {
         std::cerr << "ERROR: More than one input file specified\n";
         options.parsing_failed_ = true;
         break;
       }
@@ skipping 54 matching lines @@
     if (line.compare(0, 11, "pool type: ") == 0) {
       const_pool_type_ = ParseConstantPoolType(line.c_str() + 11);
     } else if (line.compare(0, 9, "execute: ") == 0) {
       execute_ = ParseBoolean(line.c_str() + 9);
     } else if (line.compare(0, 6, "wrap: ") == 0) {
       wrap_ = ParseBoolean(line.c_str() + 6);
     } else if (line.compare(0, 20, "test function name: ") == 0) {
       test_function_name_ = line.c_str() + 20;
     } else if (line.compare(0, 11, "top level: ") == 0) {
       top_level_ = ParseBoolean(line.c_str() + 11);
+    } else if (line.compare(0, 14, "legacy const: ") == 0) {
+      legacy_const_ = ParseBoolean(line.c_str() + 14);
+    } else if (line.compare(0, 16, "do expressions: ") == 0) {
+      do_expressions_ = ParseBoolean(line.c_str() + 16);
     } else if (line == "---") {
       break;
     } else if (line.empty()) {
       continue;
     } else {
       UNREACHABLE();
       return;
     }
   }
 }
 
 void ProgramOptions::PrintHeader(std::ostream& stream) const {  // NOLINT
   stream << "---"
             "\npool type: "
          << ConstantPoolTypeToString(const_pool_type_)
          << "\nexecute: " << BooleanToString(execute_)
          << "\nwrap: " << BooleanToString(wrap_);
 
   if (!test_function_name_.empty()) {
     stream << "\ntest function name: " << test_function_name_;
   }
 
   if (top_level_) stream << "\ntop level: yes";
+  if (legacy_const_) stream << "\nlegacy const: yes";
+  if (do_expressions_) stream << "\ndo expressions: yes";
 
   stream << "\n\n";
 }
 
 V8InitializationScope::V8InitializationScope(const char* exec_path)
     : platform_(v8::platform::CreateDefaultPlatform()) {
   i::FLAG_ignition = true;
   i::FLAG_always_opt = false;
   i::FLAG_allow_natives_syntax = true;
 
@@ skipping 86 matching lines @@
 
     BytecodeExpectationsPrinter printer(platform.isolate(),
                                         options.const_pool_type());
     printer.set_wrap(options.wrap());
     printer.set_execute(options.execute());
     printer.set_top_level(options.top_level());
     if (!options.test_function_name().empty()) {
       printer.set_test_function_name(options.test_function_name());
     }
 
+    if (options.legacy_const()) i::FLAG_legacy_const = true;
+    if (options.do_expressions()) i::FLAG_harmony_do_expressions = true;
+
     stream << "#\n# Autogenerated by generate-bytecode-expectations\n#\n\n";
     options.PrintHeader(stream);
     for (const std::string& snippet : snippet_list) {
       printer.PrintExpectation(stream, snippet);
     }
   }
 }
 
 void PrintUsage(const char* exec_path) {
   std::cerr
       << "\nUsage: " << exec_path
       << " [OPTIONS]... [INPUT FILE]\n\n"
          "Options:\n"
          "  --help    Print this help message.\n"
          "  --raw-js  Read raw JavaScript, instead of the output format.\n"
          "  --stdin   Read from standard input instead of file.\n"
          "  --rebaseline  Rebaseline input snippet file.\n"
          "  --no-wrap     Do not wrap the snippet in a function.\n"
          "  --no-execute  Do not execute after compilation.\n"
          "  --test-function-name=foo  "
          "Specify the name of the test function.\n"
          "  --top-level   Process top level code, not the top-level function."
+         "  --legacy-const  Enable legacy_const flag.\n"
+         "  --do-expressions  Enable harmony_do_expressions flag.\n"
          "  --output=file.name\n"
          "      Specify the output file. If not specified, output goes to "
          "stdout.\n"
          "  --pool-type=(int|double|string|mixed)\n"
          "      Specify the type of the entries in the constant pool "
          "(default: mixed).\n"
          "\n"
          "When using --rebaseline, flags --no-wrap, --no-execute, "
          "--test-function-name\nand --pool-type will be overridden by the "
          "options specified in the input file\nheader.\n\n"
@@ skipping 42 matching lines @@
       std::cerr << "ERROR: Could not open '" << options.output_filename()
                 << "' for writing.\n";
       return 3;
     }
   }
   std::ostream& output_stream =
       options.write_to_stdout() ? std::cout : output_file_handle;
 
   GenerateExpectationsFile(output_stream, snippet_list, options, argv[0]);
 }