[wasm] Add test for detailed stack trace

test/cctest/wasm/test-wasm-stack.cc

+// Copyright 2016 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/wasm/wasm-macro-gen.h"
+
+#include "test/cctest/cctest.h"
+#include "test/cctest/compiler/value-helper.h"
+#include "test/cctest/wasm/test-signatures.h"
+#include "test/cctest/wasm/wasm-run-utils.h"
+
+using namespace v8::base;
+using namespace v8::internal;
+using namespace v8::internal::compiler;
+using namespace v8::internal::wasm;
+
+using v8::Local;
+using v8::Utils;
+
+namespace {  // anonymous

[JF, 2016/04/11 18:12:00]

The rest of the codebecase doesn't comment on anonymous namespace.

[Clemens Hammacher, 2016/04/12 08:30:48]

Done.

+
+#define CHECK_CSTREQ(exp, found)                                           \
+  do {                                                                     \
+    if (V8_UNLIKELY(strcmp(exp, found) != 0)) {                            \
+      V8_Fatal(__FILE__, __LINE__,                                         \
+               "Check failed: (%s) != (%s) ('%s' vs '%s').", #exp, #found, \
+               exp, found);                                                \
+    }                                                                      \
+  } while (0)

[JF, 2016/04/11 18:12:00]

This is better because it prevents re-evaluating the macro arguments:

#define CHECK_CSTREQ(exp, found)                                           \
  do {                                                                     \
    const char *exp_ = (exp);                                              \
    const char *found_ = (found);                                          \
    if (V8_UNLIKELY(strcmp(exp_, found_) != 0)) {                          \
      V8_Fatal(__FILE__, __LINE__,                                         \
               "Check failed: (%s) != (%s) ('%s' vs '%s').", #exp, #found, \
               exp_, found_);                                              \
    }                                                                      \
  } while (0)

[Clemens Hammacher, 2016/04/12 08:30:48]

Done.

+
+void PrintStackTrace(v8::Local<v8::StackTrace> stack) {
+  printf("Stack Trace (length %d):\n", stack->GetFrameCount());
+  for (int i = 0, e = stack->GetFrameCount(); i != e; ++i) {
+    v8::Local<v8::StackFrame> frame = stack->GetFrame(i);
+    USE(frame);

[JF, 2016/04/11 18:12:00]

This isn't necessary? frame is used below.

[Clemens Hammacher, 2016/04/12 08:30:48]

Right, I removed it.

+    v8::Local<v8::String> script = frame->GetScriptName();
+    v8::Local<v8::String> func = frame->GetFunctionName();
+    printf("[%d] (%s) %s:%d:%d\n", i,
+           script.IsEmpty() ? "<null>" : *v8::String::Utf8Value(script),
+           func.IsEmpty() ? "<null>" : *v8::String::Utf8Value(func),
+           frame->GetLineNumber(), frame->GetColumn());
+  }
+}
+
+template <int N>
+void CheckExceptionInfos(Isolate* isolate, Handle<Object> exc,
+                         const char* (&functionNames)[N],
+                         int (&lineNumbers)[N]) {

[JF, 2016/04/11 18:12:00]

Passing in std::vector would be cleaner than templating on size. You could
create a struct { const char *funname; int lineno; } and pass that in.

[Clemens Hammacher, 2016/04/12 08:30:48]

Not all buildbots can create std::vector from initializer list, so using
std::vector would blow up the code on each caller. Same problem for Vector.
(edit: I just see that initializer lists are banned anyway:
https://chromium-cpp.appspot.com/)

I updated the patch to use a struct tough. That's indeed much nicer.
Alternatively, I could add a new Vector constructor from an array reference,
like that:

  template <int N>
  Vector(T (&arr)[N]) : start_(arr), length_(N) {}

I would like that, but I did not want to touch such a central data structure ;)

+  // check that it's indeed an Error object
+  CHECK(Object::IsErrorObject(isolate, exc));
+
+  // extract stack frame from exception
+  Local<v8::Value> localExc = Utils::ToLocal(exc);
+  v8::Local<v8::StackTrace> stack = v8::Exception::GetStackTrace(localExc);
+  PrintStackTrace(stack);
+  CHECK(!stack.IsEmpty());
+  CHECK_EQ(N, stack->GetFrameCount());
+
+  for (int frameNr = 0; frameNr < N; ++frameNr) {
+    v8::Local<v8::StackFrame> frame = stack->GetFrame(frameNr);
+    v8::String::Utf8Value funName(frame->GetFunctionName());
+    CHECK_CSTREQ(functionNames[frameNr], *funName);
+    CHECK_EQ(lineNumbers[frameNr], frame->GetLineNumber());
+  }
+}
+
+}  // anonymous namespace
+
+// Call from JS to WASM to JS and throw an Error from JS.
+TEST(CollectDetailedWasmStack_ExplicitThrowFromJs) {
+  TestSignatures sigs;
+  TestingModule module;
+
+  WasmFunctionCompiler comp1(sigs.v_v(), &module);
+
+  uint32_t jsThrowingIndex = module.AddJsFunction(
+      sigs.v_v(),
+      "(function js() {\n function a() {\n throw new Error(); };\n a(); })");
+
+  BUILD(comp1, WASM_CALL_FUNCTION0(jsThrowingIndex));
+  uint32_t wasmIndex = comp1.CompileAndAdd();
+
+  WasmFunctionCompiler comp2(sigs.v_v(), &module);
+  BUILD(comp2, WASM_CALL_FUNCTION0(wasmIndex));
+  uint32_t wasmIndex2 = comp2.CompileAndAdd();
+
+  Handle<JSFunction> jsWasmWrapper = module.WrapCode(wasmIndex2);
+
+  Handle<JSFunction> jsTrampoline = Handle<JSFunction>::cast(
+      v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+          CompileRun("(function callFn(fn) { fn(); })"))));
+
+  Isolate* isolate = jsWasmWrapper->GetIsolate();
+  isolate->SetCaptureStackTraceForUncaughtExceptions(true, 10,
+                                                     v8::StackTrace::kOverview);
+  Handle<Object> global(isolate->context()->global_object(), isolate);
+  MaybeHandle<Object> excMaybe;
+  Handle<Object> args[] = {jsWasmWrapper};
+  MaybeHandle<Object> returnObjMaybe =
+      Execution::TryCall(isolate, jsTrampoline, global, 1, args, &excMaybe);
+  CHECK(returnObjMaybe.is_null());
+
+  const char* funcNames[] = {"a", "js", "<WASM>", "<WASM>", "callFn"};
+  // line number is 1-based, with 0 == kNoLineNumberInfo
+  int lineNrs[] = {3, 4, 0, 0, 1};
+  CheckExceptionInfos(isolate, excMaybe.ToHandleChecked(), funcNames, lineNrs);
+}