[interpreter] Switch context during 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 4242 matching lines @@
     CheckBytecodeArrayEqual(snippets[i], bytecode_array);
   }
 }
 
 
 TEST(TryCatch) {
   InitializedHandleScope handle_scope;
   BytecodeGeneratorHelper helper;
 
   int closure = Register::function_closure().index();
+  int context = Register::current_context().index();
 
   ExpectedSnippet<const char*> snippets[] = {
       {"try { return 1; } catch(e) { return 2; }",
        5 * kPointerSize,
        1,
-       36,
+       39,
        {
+           B(Mov), R(context), R(1),                                       //
            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(Star), R(1),                                                  //
            B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage),  //
            /*           */ R(0), U8(0),                                    //
            B(Ldar), R(1),                                                  //
            B(PushContext), R(0),                                           //
            B(LdaSmi8), U8(2),                                              //
            B(PopContext), R(0),                                            //
            B(Return),                                                      //
            // TODO(mstarzinger): Potential optimization, elide next bytes.
            B(LdaUndefined),  //
            B(Return),        //
        },
        1,
        {"e"},
        1,
-       {{0, 3, 3}}},
+       {{3, 6, 6}}},
       {"var a; try { a = 1 } catch(e1) {}; try { a = 2 } catch(e2) { a = 3 }",
        6 * kPointerSize,
        1,
-       74,
+       80,
        {
+           B(Mov), R(context), R(2),                                       //
            B(LdaSmi8), U8(1),                                              //
            B(Star), R(0),                                                  //
            B(Jump), U8(30),                                                //
            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(Star), R(2),                                                  //
            B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage),  //
            /*           */ R(0), U8(0),                                    //
            B(Ldar), R(2),                                                  //
            B(PushContext), R(1),                                           //
            B(PopContext), R(1),                                            //
+           B(Mov), R(context), R(2),                                       //
            B(LdaSmi8), U8(2),                                              //
            B(Star), R(0),                                                  //
            B(Jump), U8(34),                                                //
            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(Star), R(2),                                                  //
            B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage),  //
            /*           */ R(0), U8(0),                                    //
            B(Ldar), R(2),                                                  //
            B(PushContext), R(1),                                           //
            B(LdaSmi8), U8(3),                                              //
            B(Star), R(0),                                                  //
            B(PopContext), R(1),                                            //
            B(LdaUndefined),                                                //
            B(Return),                                                      //
        },
        2,
        {"e1", "e2"},
        2,
-       {{0, 4, 6}, {34, 38, 40}}},
+       {{3, 7, 9}, {40, 44, 46}}},
   };
 
   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::current_context().index();
 
   ExpectedSnippet<const char*> snippets[] = {
       {"var a = 1; try { a = 2; } finally { a = 3; }",
        4 * kPointerSize,
        1,
-       47,
+       50,
        {
            B(LdaSmi8), U8(1),                                              //
            B(Star), R(0),                                                  //
+           B(Mov), R(context), R(3),                                       //
            B(LdaSmi8), U8(2),                                              //
            B(Star), R(0),                                                  //
            B(LdaSmi8), U8(-1),                                             //
            B(Star), R(1),                                                  //
            B(Jump), U8(7),                                                 //
            B(Star), R(2),                                                  //
            B(LdaZero),                                                     //
            B(Star), R(1),                                                  //
            B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage),  //
            /*           */ R(0), U8(0),                                    //
            B(Star), R(3),                                                  //
            B(LdaSmi8), U8(3),                                              //
            B(Star), R(0),                                                  //
            B(CallRuntime), U16(Runtime::kInterpreterSetPendingMessage),    //
            /*           */ R(3), U8(1),                                    //
            B(LdaZero),                                                     //
            B(TestEqualStrict), R(1),                                       //
            B(JumpIfTrue), U8(4),                                           //
            B(Jump), U8(5),                                                 //
            B(Ldar), R(2),                                                  //
            B(ReThrow),                                                     //
            B(LdaUndefined),                                                //
            B(Return),                                                      //
        },
        0,
        {},
        1,
-       {{4, 8, 14}}},
+       {{7, 11, 17}}},
       {"var a = 1; try { a = 2; } catch(e) { a = 20 } finally { a = 3; }",
        9 * kPointerSize,
        1,
-       81,
+       87,
        {
            B(LdaSmi8), U8(1),                                              //
            B(Star), R(0),                                                  //
+           B(Mov), R(context), R(4),                                       //
+           B(Mov), R(context), R(5),                                       //
            B(LdaSmi8), U8(2),                                              //
            B(Star), R(0),                                                  //
            B(Jump), U8(34),                                                //
            B(Star), R(7),                                                  //
            B(LdaConstant), U8(0),                                          //
            B(Star), R(6),                                                  //
            B(Ldar), R(closure),                                            //
            B(Star), R(8),                                                  //
            B(CallRuntime), U16(Runtime::kPushCatchContext), R(6), U8(3),   //
            B(Star), R(5),                                                  //
@@ skipping 22 matching lines @@
            B(JumpIfTrue), U8(4),                                           //
            B(Jump), U8(5),                                                 //
            B(Ldar), R(3),                                                  //
            B(ReThrow),                                                     //
            B(LdaUndefined),                                                //
            B(Return),                                                      //
        },
        1,
        {"e"},
        2,
-       {{4, 42, 48}, {4, 8, 10}}},
+       {{7, 48, 54}, {10, 14, 16}}},
       {"var a; try {"
        "  try { a = 1 } catch(e) { a = 2 }"
        "} catch(e) { a = 20 } finally { a = 3; }",
        10 * kPointerSize,
        1,
-       111,
+       120,
        {
+           B(Mov), R(context), R(4),                                       //
+           B(Mov), R(context), R(5),                                       //
+           B(Mov), R(context), R(6),                                       //
            B(LdaSmi8), U8(1),                                              //
            B(Star), R(0),                                                  //
            B(Jump), U8(34),                                                //
            B(Star), R(8),                                                  //
            B(LdaConstant), U8(0),                                          //
            B(Star), R(7),                                                  //
            B(Ldar), R(closure),                                            //
            B(Star), R(9),                                                  //
            B(CallRuntime), U16(Runtime::kPushCatchContext), R(7), U8(3),   //
            B(Star), R(6),                                                  //
@@ skipping 37 matching lines @@
            B(JumpIfTrue), U8(4),                                           //
            B(Jump), U8(5),                                                 //
            B(Ldar), R(3),                                                  //
            B(ReThrow),                                                     //
            B(LdaUndefined),                                                //
            B(Return),                                                      //
        },
        1,
        {"e"},
        3,
-       {{0, 72, 78}, {0, 38, 40}, {0, 4, 6}}},
+       {{3, 81, 87}, {6, 47, 49}, {9, 13, 15}}},
   };
 
   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 3225 matching lines @@
   for (size_t i = 0; i < arraysize(snippets); i++) {
     Handle<BytecodeArray> bytecode_array =
         helper.MakeBytecodeForFunctionBody(snippets[i].code_snippet);
     CheckBytecodeArrayEqual(snippets[i], bytecode_array);
   }
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8