[interpreter] First implementation of stack unwinding.

test/cctest/interpreter/test-bytecode-generator.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.h"
 #include "src/interpreter/bytecode-array-iterator.h"
 #include "src/interpreter/bytecode-generator.h"
 #include "src/interpreter/interpreter.h"
@@ skipping 4149 matching lines @@
     CheckBytecodeArrayEqual(snippets[i], bytecode_array);
   }
 }
 
 
 TEST(TryCatch) {
   InitializedHandleScope handle_scope;
   BytecodeGeneratorHelper helper;
 
   int closure = Register::function_closure().index();
+  int context = Register::function_context().index();
 
   ExpectedSnippet<const char*> snippets[] = {
       {"try { return 1; } catch(e) { return 2; }",
        5 * kPointerSize,
        1,
-       23,
+       25,
        {
            B(LdaSmi8), U8(1),                                             //
            B(Return),                                                     //
            B(Star), R(3),                                                 //
            B(LdaConstant), U8(0),                                         //
            B(Star), R(2),                                                 //
            B(Ldar), R(closure),                                           //
            B(Star), R(4),                                                 //
            B(CallRuntime), U16(Runtime::kPushCatchContext), R(2), U8(3),  //
+           B(PushContext), R(0),                                          //
            B(LdaSmi8), U8(2),                                             //
            B(Return),                                                     //
            // TODO(mstarzinger): Potential optimization, elide next bytes.
            B(LdaUndefined),  //
            B(Return),        //
        },
        1,
        {"e"},
        1,
        {{0, 3, 3}}},
       {"var a; try { a = 1 } catch(e1) {}; try { a = 2 } catch(e2) { a = 3 }",
        6 * kPointerSize,
        1,
-       48,
+       56,
        {
            B(LdaSmi8), U8(1),                                             //
            B(Star), R(0),                                                 //
-           B(Jump), U8(17),                                               //
+           B(Jump), U8(21),                                               //
            B(Star), R(4),                                                 //
            B(LdaConstant), U8(0),                                         //
            B(Star), R(3),                                                 //
            B(Ldar), R(closure),                                           //
            B(Star), R(5),                                                 //
            B(CallRuntime), U16(Runtime::kPushCatchContext), R(3), U8(3),  //
+           B(PushContext), R(1),                                          //
+           B(PopContext), R(context),                                     //
            B(LdaSmi8), U8(2),                                             //
            B(Star), R(0),                                                 //
-           B(Jump), U8(21),                                               //
+           B(Jump), U8(25),                                               //
            B(Star), R(4),                                                 //
            B(LdaConstant), U8(1),                                         //
            B(Star), R(3),                                                 //
            B(Ldar), R(closure),                                           //
            B(Star), R(5),                                                 //
            B(CallRuntime), U16(Runtime::kPushCatchContext), R(3), U8(3),  //
+           B(PushContext), R(1),                                          //
            B(LdaSmi8), U8(3),                                             //
            B(Star), R(0),                                                 //
+           B(PopContext), R(context),                                     //
            B(LdaUndefined),                                               //
            B(Return),                                                     //
        },
        2,
        {"e1", "e2"},
        2,
-       {{0, 4, 6}, {21, 25, 27}}},
+       {{0, 4, 6}, {25, 29, 31}}},
   };
 
   for (size_t i = 0; i < arraysize(snippets); i++) {
     Handle<BytecodeArray> bytecode_array =
         helper.MakeBytecodeForFunctionBody(snippets[i].code_snippet);
     CheckBytecodeArrayEqual(snippets[i], bytecode_array);
   }
 }
 
 
 TEST(TryFinally) {
   InitializedHandleScope handle_scope;
   BytecodeGeneratorHelper helper;
 
   int closure = Register::function_closure().index();
+  int context = Register::function_context().index();
 
   ExpectedSnippet<const char*> snippets[] = {
       {"var a = 1; try { a = 2; } finally { a = 3; }",
        2 * kPointerSize,
        1,
        14,
        {
            B(LdaSmi8), U8(1),  //
            B(Star), R(0),      //
            B(LdaSmi8), U8(2),  //
            B(Star), R(0),      //
            B(LdaSmi8), U8(3),  //
            B(Star), R(0),      //
            B(LdaUndefined),    //
            B(Return),          //
        },
        0,
        {},
        1,
        {{4, 8, 8}}},
       {"var a = 1; try { a = 2; } catch(e) { a = 20 } finally { a = 3; }",
        7 * kPointerSize,
        1,
-       35,
+       39,
        {
            B(LdaSmi8), U8(1),                                             //
            B(Star), R(0),                                                 //
            B(LdaSmi8), U8(2),                                             //
            B(Star), R(0),                                                 //
-           B(Jump), U8(21),                                               //
+           B(Jump), U8(25),                                               //
            B(Star), R(5),                                                 //
            B(LdaConstant), U8(0),                                         //
            B(Star), R(4),                                                 //
            B(Ldar), R(closure),                                           //
            B(Star), R(6),                                                 //
            B(CallRuntime), U16(Runtime::kPushCatchContext), R(4), U8(3),  //
+           B(PushContext), R(1),                                          //
            B(LdaSmi8), U8(20),                                            //
            B(Star), R(0),                                                 //
+           B(PopContext), R(context),                                     //
            B(LdaSmi8), U8(3),                                             //
            B(Star), R(0),                                                 //
            B(LdaUndefined),                                               //
            B(Return),                                                     //
        },
        1,
        {"e"},
        2,
-       {{4, 29, 29}, {4, 8, 10}}},
+       {{4, 33, 33}, {4, 8, 10}}},
       {"var a; try {"
        "  try { a = 1 } catch(e) { a = 2 }"
        "} catch(e) { a = 20 } finally { a = 3; }",
        8 * kPointerSize,
        1,
-       52,
+       60,
        {
            B(LdaSmi8), U8(1),                                             //
            B(Star), R(0),                                                 //
-           B(Jump), U8(21),                                               //
+           B(Jump), U8(25),                                               //
            B(Star), R(6),                                                 //
            B(LdaConstant), U8(0),                                         //
            B(Star), R(5),                                                 //
            B(Ldar), R(closure),                                           //
            B(Star), R(7),                                                 //
            B(CallRuntime), U16(Runtime::kPushCatchContext), R(5), U8(3),  //
+           B(PushContext), R(1),                                          //
            B(LdaSmi8), U8(2),                                             //
            B(Star), R(0),                                                 //
-           B(Jump), U8(21),                                               //
+           B(PopContext), R(context),                                     //
+           B(Jump), U8(25),                                               //
            B(Star), R(5),                                                 //
            B(LdaConstant), U8(0),                                         //
            B(Star), R(4),                                                 //
            B(Ldar), R(closure),                                           //
            B(Star), R(6),                                                 //
            B(CallRuntime), U16(Runtime::kPushCatchContext), R(4), U8(3),  //
+           B(PushContext), R(1),                                          //
            B(LdaSmi8), U8(20),                                            //
            B(Star), R(0),                                                 //
+           B(PopContext), R(context),                                     //
            B(LdaSmi8), U8(3),                                             //
            B(Star), R(0),                                                 //
            B(LdaUndefined),                                               //
            B(Return),                                                     //
        },
        1,
        {"e"},
        3,
-       {{0, 46, 46}, {0, 25, 27}, {0, 4, 6}}},
+       {{0, 54, 54}, {0, 29, 31}, {0, 4, 6}}},
   };
 
   for (size_t i = 0; i < arraysize(snippets); i++) {
     Handle<BytecodeArray> bytecode_array =
         helper.MakeBytecodeForFunctionBody(snippets[i].code_snippet);
     CheckBytecodeArrayEqual(snippets[i], bytecode_array);
   }
 }
 
 
@@ skipping 2548 matching lines @@
                          std::string(function_epilogue);
     Handle<BytecodeArray> bytecode_array =
         helper.MakeBytecode(script.c_str(), "*", "f");
     CheckBytecodeArrayEqual(snippets[i], bytecode_array);
   }
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8