[interpreter] Fix bogus test expecation for bytecode generator.

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 4256 matching lines @@
   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,
-       25,
+       27,
        {
            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(PopContext), R(context),                                     //
            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 }",
@@ skipping 316 matching lines @@
   BytecodeGeneratorHelper helper;
   Zone zone;
 
   FeedbackVectorSpec feedback_spec(&zone);
   FeedbackVectorSlot slot = feedback_spec.AddCallICSlot();
 
   Handle<i::TypeFeedbackVector> vector =
       i::NewTypeFeedbackVector(helper.isolate(), &feedback_spec);
 
   int closure = Register::function_closure().index();
+  int context = Register::function_context().index();
   int new_target = Register::new_target().index();
   int first_context_slot = Context::MIN_CONTEXT_SLOTS;
 
   // The wide check below relies on MIN_CONTEXT_SLOTS + 3 + 249 == 256, if this
   // ever changes, the REPEAT_XXX should be changed to output the correct number
   // of unique variables to trigger the wide slot load / store.
   STATIC_ASSERT(Context::MIN_CONTEXT_SLOTS + 3 + 249 == 256);
   int wide_slot = first_context_slot + 3;
 
   ExpectedSnippet<InstanceType> snippets[] = {
@@ skipping 56 matching lines @@
            B(Star), R(1),                                           //
            B(Call), R(1), R(2), U8(0), U8(vector->GetIndex(slot)),  //
            B(LdaContextSlot), R(0), U8(first_context_slot),         //
            B(Return),                                               //
        },
        1,
        {InstanceType::SHARED_FUNCTION_INFO_TYPE}},
       {"'use strict'; let a = 1; { let b = 2; return function() { a + b; }; }",
        4 * kPointerSize,
        1,
-       44,
+       46,
        {
            B(CallRuntime), U16(Runtime::kNewFunctionContext),             //
                            R(closure), U8(1),                             //
            B(PushContext), R(0),                                          //
            B(LdaTheHole),                                                 //
            B(StaContextSlot), R(0), U8(first_context_slot),               //
            B(LdaSmi8), U8(1),                                             //
            B(StaContextSlot), R(0), U8(first_context_slot),               //
            B(LdaConstant), U8(0),                                         //
            B(Star), R(2),                                                 //
            B(Ldar), R(closure),                                           //
            B(Star), R(3),                                                 //
            B(CallRuntime), U16(Runtime::kPushBlockContext), R(2), U8(2),  //
            B(PushContext), R(1),                                          //
            B(LdaTheHole),                                                 //
            B(StaContextSlot), R(1), U8(first_context_slot),               //
            B(LdaSmi8), U8(2),                                             //
            B(StaContextSlot), R(1), U8(first_context_slot),               //
            B(CreateClosure), U8(1), U8(0),                                //
+           B(PopContext), R(context),                                     //
            B(Return),                                                     //
        },
        2,
        {InstanceType::FIXED_ARRAY_TYPE,
         InstanceType::SHARED_FUNCTION_INFO_TYPE}},
       {"'use strict';\n"
        REPEAT_249_UNIQUE_VARS()
        "eval();"
        "var b = 100;"
        "return b",
@@ skipping 2302 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