[builtins] support exception handling in TFJ builtins

src/isolate.cc

 // Copyright 2012 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/isolate.h"
 
 #include <stdlib.h>
 
 #include <fstream>  // NOLINT(readability/streams)
 #include <sstream>
@@ skipping 1262 matching lines @@
         context = Context::cast(Memory::Object_at(return_sp - kPointerSize));
 
         // Gather information from the frame.
         code = frame->LookupCode();
         handler_sp = return_sp;
         handler_fp = frame->fp();
         break;
       }
     }
 
+    if (frame->is_stub() && catchable_by_js) {
+      StubFrame* stub_frame = StubFrame::cast(frame);
+      int stack_depth = 0;
+      int code_offset =
+          stub_frame->LookupExceptionHandlerInTable(&stack_depth, nullptr);
+      if (code_offset >= 0) {
+        Address return_sp = frame->fp() -
+                            StandardFrameConstants::kFixedFrameSizeFromFp -
+                            stack_depth * kPointerSize;
+        STATIC_ASSERT(TryBlockConstant::kElementCount == 1);
+        Object* maybe_context = Memory::Object_at(return_sp - kPointerSize);
+        context = maybe_context->IsContext() ? Context::cast(maybe_context)
+                                             : raw_native_context();

[caitp, 2016/08/18 03:08:57]

I'm not sure about this:

For TFJ builtins, it looks like the frame should be more or less identical to
normal JS frames, however `maybe_context` is never a Context in the cctests
provided. I haven't checked if this would behave differently with proper TFJ
builtins or not yet.

Since stubs are basically internal, I think always using the currently entered
context is _probably_ fine though, but maybe not?

+
+        code = frame->LookupCode();
+        handler_sp = return_sp;
+        handler_fp = frame->fp();
+        offset = code_offset;

[caitp, 2016/08/18 03:08:57]

Without setting the offset, the stub is restarted from the beginning, and it
gets ugly and breaks things. I'm not actually 100% sure this does work, but it
does seem to get to the right spot, at least (in the two test cases).

+        break;
+      }
+    }
+
     RemoveMaterializedObjectsOnUnwind(frame);
   }
 
   // Handler must exist.
   CHECK(code != nullptr);
 
   // Store information to be consumed by the CEntryStub.
   thread_local_top()->pending_handler_context_ = context;
   thread_local_top()->pending_handler_code_ = code;
   thread_local_top()->pending_handler_offset_ = offset;
@@ skipping 1903 matching lines @@
   // Then check whether this scope intercepts.
   if ((flag & intercept_mask_)) {
     intercepted_flags_ |= flag;
     return true;
   }
   return false;
 }
 
 }  // namespace internal
 }  // namespace v8