[interpreter] Implement exception handler table building.

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 143 matching lines @@
 // Structure for containing expected bytecode snippets.
 template<typename T, int C = 6>
 struct ExpectedSnippet {
   const char* code_snippet;
   int frame_size;
   int parameter_count;
   int bytecode_length;
   const uint8_t bytecode[2048];
   int constant_count;
   T constants[C];
+  int handler_count;
+  struct {
+    int start;
+    int end;
+    int handler;
+  } handlers[C];
 };
 
 
 static void CheckConstant(int expected, Object* actual) {
   CHECK_EQ(expected, Smi::cast(actual)->value());
 }
 
 
 static void CheckConstant(double expected, Object* actual) {
   CHECK_EQ(expected, HeapNumber::cast(actual)->value());
@@ skipping 24 matching lines @@
   CHECK_EQ(expected.parameter_count, actual->parameter_count());
   CHECK_EQ(expected.bytecode_length, actual->length());
   if (expected.constant_count == 0) {
     CHECK_EQ(CcTest::heap()->empty_fixed_array(), actual->constant_pool());
   } else {
     CHECK_EQ(expected.constant_count, actual->constant_pool()->length());
     for (int i = 0; i < expected.constant_count; i++) {
       CheckConstant(expected.constants[i], actual->constant_pool()->get(i));
     }
   }
+  if (expected.handler_count == 0) {
+    CHECK_EQ(CcTest::heap()->empty_fixed_array(), actual->handler_table());
+  } else {
+    static const int kHTSize = 4;     // see HandlerTable::kRangeEntrySize
+    static const int kHTStart = 0;    // see HandlerTable::kRangeStartIndex
+    static const int kHTEnd = 1;      // see HandlerTable::kRangeEndIndex
+    static const int kHTHandler = 2;  // see HandlerTable::kRangeHandlerIndex
+    HandlerTable* table = HandlerTable::cast(actual->handler_table());
+    CHECK_EQ(expected.handler_count * kHTSize, table->length());
+    for (int i = 0; i < expected.handler_count; i++) {
+      int start = Smi::cast(table->get(i * kHTSize + kHTStart))->value();
+      int end = Smi::cast(table->get(i * kHTSize + kHTEnd))->value();
+      int handler = Smi::cast(table->get(i * kHTSize + kHTHandler))->value();
+      CHECK_EQ(expected.handlers[i].start, start);
+      CHECK_EQ(expected.handlers[i].end, end);
+      CHECK_EQ(expected.handlers[i].handler, handler >> 1);
+    }
+  }
 
   BytecodeArrayIterator iterator(actual);
   int i = 0;
   while (!iterator.done()) {
     int bytecode_index = i++;
     Bytecode bytecode = iterator.current_bytecode();
     if (Bytecodes::ToByte(bytecode) != expected.bytecode[bytecode_index]) {
       std::ostringstream stream;
       stream << "Check failed: expected bytecode [" << bytecode_index
              << "] to be " << Bytecodes::ToString(static_cast<Bytecode>(
@@ skipping 3918 matching lines @@
         helper.MakeTopLevelBytecode(snippets[i].code_snippet);
     CheckBytecodeArrayEqual(snippets[i], bytecode_array);
   }
 }
 
 
 TEST(TryCatch) {
   InitializedHandleScope handle_scope;
   BytecodeGeneratorHelper helper;
 
-  // TODO(rmcilroy): modify tests when we have real try catch support.
-  ExpectedSnippet<int> snippets[] = {
+  int closure = Register::function_closure().index();
+
+  ExpectedSnippet<const char*> snippets[] = {
       {"try { return 1; } catch(e) { return 2; }",
-       kPointerSize,
+       5 * kPointerSize,
        1,
-       3,
+       23,
        {
-           B(LdaSmi8), U8(1),  //
-           B(Return),          //
+           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(LdaSmi8), U8(2),                                             //
+           B(Return),                                                     //
+           // TODO(mstarzinger): Potential optimization, elide next bytes.
+           B(LdaUndefined),  //
+           B(Return),        //
        },
-       0},
+       1,
+       {"e"},
+       1,
+       {{0, 3, 3}}},
   };
 
   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;
 
-  // TODO(rmcilroy): modify tests when we have real try finally support.
-  ExpectedSnippet<int> snippets[] = {
+  int closure = Register::function_closure().index();
+
+  ExpectedSnippet<const char*> snippets[] = {
       {"var a = 1; try { a = 2; } finally { a = 3; }",
-       kPointerSize,
+       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},
+       0,
+       {},
+       1,
+       {{4, 8, 8}}},
       {"var a = 1; try { a = 2; } catch(e) { a = 20 } finally { a = 3; }",
-       2 * kPointerSize,
+       7 * kPointerSize,
        1,
-       14,
+       35,
        {
-           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),          //
+           B(LdaSmi8), U8(1),                                             //

[oth, 2016/01/20 08:01:33]

Tests are a bit brief. Could we add a couple of more, perhaps:

1) two try...catch...blocks not nested.
2) nested try...catch...finally.

[Michael Starzinger, 2016/01/20 10:19:54]

Done, (1) in the test above and (2) here.

+           B(Star), R(0),                                                 //
+           B(LdaSmi8), U8(2),                                             //
+           B(Star), R(0),                                                 //
+           B(Jump), U8(21),                                               //
+           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(LdaSmi8), U8(20),                                            //
+           B(Star), R(0),                                                 //
+           B(LdaSmi8), U8(3),                                             //
+           B(Star), R(0),                                                 //
+           B(LdaUndefined),                                               //
+           B(Return),                                                     //
        },
-       0},
+       1,
+       {"e"},
+       2,
+       {{4, 29, 29}, {4, 8, 10}}},
   };
 
   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(Throw) {
   InitializedHandleScope handle_scope;
   BytecodeGeneratorHelper helper;
 
-  // TODO(rmcilroy): modify tests when we have real try catch support.
   ExpectedSnippet<const char*> snippets[] = {
       {"throw 1;",
        0,
        1,
        3,
        {
            B(LdaSmi8), U8(1),  //
            B(Throw),           //
        },
        0},
@@ skipping 2534 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