[wasm] Provide better stack traces for asm.js code

test/mjsunit/wasm/asm-wasm-stack.js

+// 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.
+
+// Flags: --validate-asm --allow-natives-syntax
+
+var filename = '(?:[^ ]+/)?test/mjsunit/wasm/asm-wasm-stack.js';
+filename = filename.replace(/\//g, '[/\\\\]');
+
+function checkPreformattedStack(e, expected_lines) {
+  print('preformatted stack: ' + e.stack);
+  var lines = e.stack.split('\n');
+  assertEquals(expected_lines.length, lines.length);
+  for (var i = 0; i < lines.length; ++i) {
+    assertMatches(expected_lines[i], lines[i], 'line ' + i);
+  }
+}
+
+function checkFunctionsOnCallsites(e, locations) {
+  var stack = e.stack;
+  print('callsite objects (size ' + stack.length + '):');
+  for (var i = 0; i < stack.length; ++i) {

[titzer, 2016/10/12 08:03:05]

I think we can improve the checking here by making it a bit more manual. E.g. I
have had to fix tests like this a couple of times, and it was pretty tricky to
find out which frame was mismatched and what was expected. If we rewrite this to
compare entry by entry and generate a special error message on failure
(including the index), this is way easier to fix in the future.

[Clemens Hammacher, 2016/10/12 08:17:46]

This is exactly what happens here. I first print the complete stack trace, then
compare entry by entry, and output the index (i) on error.
What was missing though was the check that the length of the stack matches. I
added this.
Am I missing something else?

+    var s = stack[i];
+    print(
+        ' [' + i + '] ' + s.getFunctionName() + ' (' + s.getFileName() + ':' +
+        s.getLineNumber() + ':' + s.getColumnNumber() + ')');
+  }
+  for (var i = 0; i < locations.length; ++i) {
+    var cs = stack[i];
+    assertMatches('^' + filename + '$', cs.getFileName(), 'file name at ' + i);
+    assertEquals(
+        locations[i][0], cs.getFunctionName(), 'function name at ' + i);
+    assertEquals(locations[i][1], cs.getLineNumber(), 'line number at ' + i);
+    assertEquals(
+        locations[i][2], cs.getColumnNumber(), 'column number at ' + i);
+    assertNotNull(cs.getThis(), 'receiver should be global');
+    assertEquals(stack[0].getThis(), cs.getThis(), 'receiver should be global');
+  }
+}
+
+function throwException() {
+  throw new Error('exception from JS');
+}
+
+function generateWasmFromAsmJs(stdlib, foreign, heap) {
+  'use asm';
+  var throwFunc = foreign.throwFunc;
+  function callThrow() {
+    throwFunc();
+  }
+  function redirectFun() {
+    callThrow();
+  }
+  return redirectFun;
+}
+
+(function PreformattedStackTraceFromJS() {
+  var fun = generateWasmFromAsmJs(this, {throwFunc: throwException}, undefined);
+  var e = null;
+  try {
+    fun();
+  } catch (ex) {
+    e = ex;
+  }
+  assertInstanceof(e, Error, 'exception should have been thrown');
+  checkPreformattedStack(e, [
+    '^Error: exception from JS$',
+    '^ *at throwException \\(' + filename + ':42:9\\)$',
+    '^ *at callThrow \\(' + filename + ':49:5\\)$',
+    '^ *at redirectFun \\(' + filename + ':52:5\\)$',
+    '^ *at PreformattedStackTraceFromJS \\(' + filename + ':61:5\\)$',
+    '^ *at ' + filename + ':74:3$'
+  ]);
+})();
+
+// Now collect the Callsite objects instead of just a string.
+Error.prepareStackTrace = function(error, frames) {
+  return frames;
+};
+
+(function CallsiteObjectsFromJS() {
+  var fun = generateWasmFromAsmJs(this, {throwFunc: throwException}, undefined);
+  var e = null;
+  try {
+    fun();
+  } catch (ex) {
+    e = ex;
+  }
+  assertInstanceof(e, Error, 'exception should have been thrown');
+  checkFunctionsOnCallsites(e, [
+    ['throwException', 42, 9],         // --
+    ['callThrow', 49, 5],              // --
+    ['redirectFun', 52, 5],            // --
+    ['CallsiteObjectsFromJS', 85, 5],  // --
+    [null, 97, 3]
+  ]);
+})();