[wasm] Implement location from stack trace for asm.js frames

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 29 matching lines @@
 #include "src/prototype.h"
 #include "src/regexp/regexp-stack.h"
 #include "src/runtime-profiler.h"
 #include "src/simulator.h"
 #include "src/snapshot/deserializer.h"
 #include "src/tracing/tracing-category-observer.h"
 #include "src/v8.h"
 #include "src/version.h"
 #include "src/vm-state-inl.h"
 #include "src/wasm/wasm-module.h"
+#include "src/wasm/wasm-objects.h"
 #include "src/zone/accounting-allocator.h"
 
 namespace v8 {
 namespace internal {
 
 base::Atomic32 ThreadId::highest_thread_id_ = 0;
 
 int ThreadId::AllocateThreadId() {
   int new_id = base::NoBarrier_AtomicIncrement(&highest_thread_id_, 1);
   return new_id;
@@ skipping 1465 matching lines @@
   Handle<Object> script = JSReceiver::GetDataProperty(
       Handle<JSObject>::cast(exception), script_symbol);
   if (!script->IsScript()) return false;
 
   Handle<Script> cast_script(Script::cast(*script));
   *target = MessageLocation(cast_script, start_pos_value, end_pos_value);
   return true;
 }
 
 
 bool Isolate::ComputeLocationFromStackTrace(MessageLocation* target,

[titzer, 2016/12/05 12:14:36]

Can you add a comment explaining what this does (basically the in-person
discussion we just had)?

[Clemens Hammacher, 2016/12/05 12:27:28]

isolate.h provides this documentation:
// Attempts to compute the current source location, storing the
// result in the target out parameter.

Isn't that enough?
The location is currently needed for generating a message object for the
uncaught exception, this message object is then delivered to the embedder by
MessageHandler::ReportMessage.
Should I add this to the comment?

                                             Handle<Object> exception) {
   if (!exception->IsJSObject()) return false;
   Handle<Name> key = factory()->stack_trace_symbol();
   Handle<Object> property =
       JSReceiver::GetDataProperty(Handle<JSObject>::cast(exception), key);
   if (!property->IsJSArray()) return false;
   Handle<JSArray> simple_stack_trace = Handle<JSArray>::cast(property);
 
   Handle<FrameArray> elements(FrameArray::cast(simple_stack_trace->elements()));
 
   const int frame_count = elements->FrameCount();
   for (int i = 0; i < frame_count; i++) {
     if (elements->IsWasmFrame(i)) {
-      // TODO(clemensh): handle wasm frames
-      return false;
+      // TODO(clemensh): Handle wasm frames if they ever need handling here.
+      continue;
+    }
+
+    if (elements->IsAsmJsWasmFrame(i)) {
+      Handle<WasmCompiledModule> compiled_module(
+          WasmInstanceObject::cast(elements->WasmInstance(i))
+              ->get_compiled_module());
+      int func_index = elements->WasmFunctionIndex(i)->value();
+      int code_offset = elements->Offset(i)->value();
+      int byte_pos = elements->Code(i)->SourcePosition(code_offset);
+      int source_pos = WasmCompiledModule::GetAsmJsSourcePosition(
+          compiled_module, func_index, byte_pos);
+      Handle<Script> script = compiled_module->script();
+
+      *target = MessageLocation(script, source_pos, source_pos + 1);
+      return true;
     }
 
     Handle<JSFunction> fun = handle(elements->Function(i), this);
     if (!fun->shared()->IsSubjectToDebugging()) continue;
 
     Object* script = fun->shared()->script();
     if (script->IsScript() &&
         !(Script::cast(script)->source()->IsUndefined(this))) {
       AbstractCode* abstract_code = elements->Code(i);
       const int code_offset = elements->Offset(i)->value();
@@ skipping 1958 matching lines @@
   // Then check whether this scope intercepts.
   if ((flag & intercept_mask_)) {
     intercepted_flags_ |= flag;
     return true;
   }
   return false;
 }
 
 }  // namespace internal
 }  // namespace v8