[wasm] Introduce WasmToInterpreterFrame

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 492 matching lines @@
 
         int flags = 0;
         if (helper.IsStrictFrame(*fun)) flags |= FrameArray::kIsStrict;
         if (exit_frame->IsConstructor()) flags |= FrameArray::kForceConstructor;
 
         elements = FrameArray::AppendJSFrame(elements, recv, fun,
                                              Handle<AbstractCode>::cast(code),
                                              offset, flags);
       } break;
 
-      case StackFrame::WASM: {
-        WasmFrame* wasm_frame = WasmFrame::cast(frame);
+      case StackFrame::WASM_COMPILED: {
+        WasmCompiledFrame* wasm_frame = WasmCompiledFrame::cast(frame);
         Handle<WasmInstanceObject> instance(wasm_frame->wasm_instance(), this);
         const int wasm_function_index = wasm_frame->function_index();
         Code* code = wasm_frame->unchecked_code();
         Handle<AbstractCode> abstract_code(AbstractCode::cast(code), this);
         const int offset =
             static_cast<int>(wasm_frame->pc() - code->instruction_start());
 
         int flags = 0;
         if (instance->compiled_module()->is_asm_js()) {
           flags |= FrameArray::kIsAsmJsWasmFrame;
           if (wasm_frame->at_to_number_conversion()) {
             flags |= FrameArray::kAsmJsAtNumberConversion;
           }
         } else {
           flags |= FrameArray::kIsWasmFrame;
         }
 
         elements =
             FrameArray::AppendWasmFrame(elements, instance, wasm_function_index,
                                         abstract_code, offset, flags);
       } break;
 
+      case StackFrame::WASM_INTERPRETER_ENTRY:
+        // TODO(clemensh): Add frames.
+        break;
+
       default:
         break;
     }
   }
 
   elements->ShrinkToFit();
 
   // TODO(yangguo): Queue this structured stack trace for preprocessing on GC.
   return factory()->NewJSArrayWithElements(elements);
 }
@@ skipping 145 matching lines @@
       Handle<Object> fun_name = JSFunction::GetDebugName(fun);
       JSObject::AddProperty(stack_frame, function_key_, fun_name, NONE);
     }
 
     // We don't have a script and hence cannot set line and col positions.
     DCHECK(!fun->shared()->script()->IsScript());
 
     return stack_frame;
   }
 
-  Handle<JSObject> NewStackFrameObject(WasmFrame* frame) {
+  Handle<JSObject> NewStackFrameObject(WasmCompiledFrame* frame) {
     Handle<JSObject> stack_frame =
         factory()->NewJSObject(isolate_->object_function());
 
     if (!function_key_.is_null()) {
       Handle<WasmCompiledModule> compiled_module(
           frame->wasm_instance()->compiled_module(), isolate_);
       Handle<String> name = WasmCompiledModule::GetFunctionName(
           isolate_, compiled_module, frame->function_index());
       JSObject::AddProperty(stack_frame, function_key_, name, NONE);
     }
@@ skipping 63 matching lines @@
         // Filter frames from other security contexts.
         if (!(options & StackTrace::kExposeFramesAcrossSecurityOrigins) &&
             !this->context()->HasSameSecurityTokenAs(fun->context()))
           continue;
         Handle<JSObject> new_frame_obj = helper.NewStackFrameObject(frames[i]);
         stack_trace_elems->set(frames_seen, *new_frame_obj);
         frames_seen++;
       }
     } else {
       DCHECK(frame->is_wasm());
-      WasmFrame* wasm_frame = WasmFrame::cast(frame);
+      WasmCompiledFrame* wasm_frame = WasmCompiledFrame::cast(frame);
       Handle<JSObject> new_frame_obj = helper.NewStackFrameObject(wasm_frame);
       stack_trace_elems->set(frames_seen, *new_frame_obj);
       frames_seen++;
     }
   }
 
   stack_trace->set_length(Smi::FromInt(frames_seen));
   return stack_trace;
 }
 
@@ skipping 416 matching lines @@
       // Gather information from the handler.
       code = frame->LookupCode();
       handler_sp = handler->address() + StackHandlerConstants::kSize;
       offset = Smi::cast(code->handler_table()->get(0))->value();
       break;
     }
 
     if (FLAG_wasm_eh_prototype) {
       if (frame->is_wasm() && is_catchable_by_wasm(exception)) {
         int stack_slots = 0;  // Will contain stack slot count of frame.
-        WasmFrame* wasm_frame = static_cast<WasmFrame*>(frame);
+        WasmCompiledFrame* wasm_frame = static_cast<WasmCompiledFrame*>(frame);
         offset = wasm_frame->LookupExceptionHandlerInTable(&stack_slots);
         if (offset >= 0) {
           // Compute the stack pointer from the frame pointer. This ensures that
           // argument slots on the stack are dropped as returning would.
           Address return_sp = frame->fp() +
                               StandardFrameConstants::kFixedFrameSizeAboveFp -
                               stack_slots * kPointerSize;
 
           // Gather information from the frame.
           code = frame->LookupCode();
@@ skipping 68 matching lines @@
       }
     }
 
     // For JavaScript frames we are guaranteed not to find a handler.
     if (frame->is_java_script() && catchable_by_js) {
       JavaScriptFrame* js_frame = static_cast<JavaScriptFrame*>(frame);
       offset = js_frame->LookupExceptionHandlerInTable(nullptr, nullptr);
       CHECK_EQ(-1, offset);
     }
 
+    // TODO(clemensh): Handle unwinding interpreted wasm frames (stored in the
+    // WasmInterpreter C++ object).
+
     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 2334 matching lines @@
   // Then check whether this scope intercepts.
   if ((flag & intercept_mask_)) {
     intercepted_flags_ |= flag;
     return true;
   }
   return false;
 }
 
 }  // namespace internal
 }  // namespace v8