[Interpreter] Add a simple dead-code elimination bytecode optimizer.

test/cctest/interpreter/test-source-positions.cc

 // Copyright 2015 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 "src/v8.h"
 
 #include "src/compiler/pipeline.h"
 #include "src/handles.h"
 #include "src/interpreter/bytecode-generator.h"
 #include "src/interpreter/interpreter.h"
 #include "src/isolate.h"
 #include "src/parsing/parser.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/interpreter/source-position-matcher.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
 // Flags enabling optimizations that change generated bytecode array.
 // Format is <command-line flag> <flag name> <bit index>
-#define OPTIMIZATION_FLAGS(V)                  \
-  V(FLAG_ignition_reo, kUseReo, 0)             \
-  V(FLAG_ignition_peephole, kUsePeephole, 1)   \
-  V(FLAG_ignition_filter_expression_positions, \
-    kUseUseFilterExpressionPositions, 2)
+#define OPTIMIZATION_FLAGS(V)                                                 \
+  V(FLAG_ignition_reo, kUseReo, 0)                                            \
+  V(FLAG_ignition_peephole, kUsePeephole, 1)                                  \
+  V(FLAG_ignition_filter_expression_positions, kUseFilterExpressionPositions, \
+    2)                                                                        \
+  V(FLAG_ignition_deadcode, kUseDeadCode, 3)
 
 #define DECLARE_BIT(_, Name, BitIndex) static const int Name = 1 << BitIndex;
 OPTIMIZATION_FLAGS(DECLARE_BIT)
 #undef DECLARE_BIT
 
 // Test cases source positions are checked for. Please ensure all
 // combinations of flags are present here. This is done manually
 // because it provides easier to comprehend failure case for humans.
-#define TEST_CASES(V)                                                    \
-  V(UsingReo, kUseReo)                                                   \
-  V(UsingPeephole, kUsePeephole)                                         \
-  V(UsingReoAndPeephole, kUseReo | kUsePeephole)                         \
-  V(UsingUseFilterExpressionPositions, kUseUseFilterExpressionPositions) \
-  V(UsingReoAndUseFilterExpressionPositions,                             \
-    kUseReo | kUseUseFilterExpressionPositions)                          \
-  V(UsingPeepholeAndUseFilterExpressionPositions,                        \
-    kUsePeephole | kUseUseFilterExpressionPositions)                     \
-  V(UsingAllOptimizations,                                               \
-    kUseReo | kUsePeephole | kUseUseFilterExpressionPositions)
+#define TEST_CASES(V)                                              \
+  V(UsingReo, kUseReo)                                             \
+  V(UsingPeephole, kUsePeephole)                                   \
+  V(UsingDeadCode, kUseDeadCode)                                   \
+  V(UsingFilterExpressionPositions, kUseFilterExpressionPositions) \
+  V(UsingReoAndPeephole, kUseReo | kUsePeephole)                   \
+  V(UsingReoAndFilterExpressionPositions,                          \
+    kUseReo | kUseFilterExpressionPositions)                       \
+  V(UsingReoAndDeadCode, kUseReo | kUseDeadCode)                   \
+  V(UsingPeepholeAndFilterExpressionPositions,                     \
+    kUsePeephole | kUseFilterExpressionPositions)                  \
+  V(UsingPeepholeAndDeadCode, kUsePeephole | kUseDeadCode)         \
+  V(UsingFilterExpressionPositionsAndDeadCode,                     \
+    kUseFilterExpressionPositions | kUseDeadCode)                  \
+  V(UsingAllOptimizations,                                         \
+    kUseReo | kUsePeephole | kUseFilterExpressionPositions | kUseDeadCode)
 
 struct TestCaseData {
   TestCaseData(const char* const script,
                const char* const declaration_parameters = "",
                const char* const arguments = "")
       : script_(script),
         declaration_parameters_(declaration_parameters),
         arguments_(arguments) {}
 
   const char* const script() const { return script_; }
@@ skipping 79 matching lines @@
 
   bool SourcePositionsMatch(int optimization_bitmap, const char* function_body,
                             const char* function_decl_params,
                             const char* function_args);
 
  private:
   Handle<BytecodeArray> MakeBytecode(int optimization_bitmap,
                                      const char* function_body,
                                      const char* function_decl_params,
                                      const char* function_args);
-  static std::string MakeFunctionName(int optimization_bitmap);
-  static std::string MakeScript(const char* function_name,
-                                const char* function_body,
+  static std::string MakeScript(const char* function_body,
                                 const char* function_decl_params,
                                 const char* function_args);
 
   void SetOptimizationFlags(int optimization_bitmap);
   void SaveOptimizationFlags();
   void RestoreOptimizationFlags();
 
   Isolate* isolate() const { return isolate_; }
 
   Isolate* isolate_;
   int saved_optimization_bitmap_;
   bool saved_flag_ignition_;
   bool saved_flag_always_opt_;
 };
 
 // static
-std::string OptimizedBytecodeSourcePositionTester::MakeFunctionName(
-    int optimization_bitmap) {
+std::string OptimizedBytecodeSourcePositionTester::MakeScript(
+    const char* function_body, const char* function_decl_params,
+    const char* function_args) {
   std::ostringstream os;
-  os << "test_function_" << optimization_bitmap;
-  return os.str();
-}
-
-// static
-std::string OptimizedBytecodeSourcePositionTester::MakeScript(
-    const char* function_name, const char* function_body,
-    const char* function_decl_params, const char* function_args) {
-  std::ostringstream os;
-  os << "function " << function_name << "(" << function_decl_params << ") {";
+  os << "function test_function"
+     << "(" << function_decl_params << ") {";
   os << function_body;
   os << "}";
-  os << function_name << "(" << function_args << ");";
+  os << "test_function(" << function_args << ");";
   return os.str();
 }
 
 Handle<BytecodeArray> OptimizedBytecodeSourcePositionTester::MakeBytecode(
     int optimization_bitmap, const char* function_body,
     const char* function_decl_params, const char* function_args) {
-  std::string function_name = MakeFunctionName(optimization_bitmap);
-  std::string script = MakeScript(function_name.c_str(), function_body,
-                                  function_decl_params, function_args);
+  std::string script =
+      MakeScript(function_body, function_decl_params, function_args);
   SetOptimizationFlags(optimization_bitmap);
   CompileRun(script.c_str());
 
-  Local<Function> api_function =
-      Local<Function>::Cast(CcTest::global()
-                                ->Get(CcTest::isolate()->GetCurrentContext(),
-                                      v8_str(function_name.c_str()))
-                                .ToLocalChecked());
+  Local<Function> api_function = Local<Function>::Cast(
+      CcTest::global()
+          ->Get(CcTest::isolate()->GetCurrentContext(), v8_str("test_function"))
+          .ToLocalChecked());
   Handle<JSFunction> function =
       Handle<JSFunction>::cast(v8::Utils::OpenHandle(*api_function));
   return handle(function->shared()->bytecode_array());
 }
 
 void OptimizedBytecodeSourcePositionTester::SetOptimizationFlags(
     int optimization_bitmap) {
 #define SET_FLAG(V8Flag, BitName, _) \
   V8Flag = (optimization_bitmap & BitName) ? true : false;
   OPTIMIZATION_FLAGS(SET_FLAG)
@@ skipping 41 matching lines @@
 #define MAKE_TEST(Name, Bitmap)               \
   TEST(TestSourcePositionsEquivalent##Name) { \
     TestSourcePositionsEquivalent(Bitmap);    \
   }
 TEST_CASES(MAKE_TEST)
 #undef MAKE_TEST
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8