[wasm] Make wasm info available on the stack trace

src/js/messages.js

 // 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.
 
 // -------------------------------------------------------------------
 
 (function(global, utils) {
 
 %CheckIsBootstrapping();
 
 // -------------------------------------------------------------------
 // Imports
 
 var ArrayJoin;
 var Bool16x8ToString;
 var Bool32x4ToString;
 var Bool8x16ToString;
 var callSiteReceiverSymbol =
     utils.ImportNow("call_site_receiver_symbol");
 var callSiteFunctionSymbol =
     utils.ImportNow("call_site_function_symbol");
 var callSitePositionSymbol =
     utils.ImportNow("call_site_position_symbol");
 var callSiteStrictSymbol =
     utils.ImportNow("call_site_strict_symbol");
+var callSiteWasmObjectSymbol =
+    utils.ImportNow("call_site_wasm_obj_symbol");
+var callSiteWasmFunctionIndexSymbol =
+    utils.ImportNow("call_site_wasm_func_index_symbol");
 var Float32x4ToString;
 var formattedStackTraceSymbol =
     utils.ImportNow("formatted_stack_trace_symbol");
 var GlobalObject = global.Object;
 var Int16x8ToString;
 var Int32x4ToString;
 var Int8x16ToString;
 var InternalArray = utils.InternalArray;
 var internalErrorSymbol = utils.ImportNow("internal_error_symbol");
 var ObjectDefineProperty;
@@ skipping 512 matching lines @@
 
 
 function GetStackTraceLine(recv, fun, pos, isGlobal) {
   return new CallSite(recv, fun, pos, false).toString();
 }
 
 // ----------------------------------------------------------------------------
 // Error implementation
 
 function CallSite(receiver, fun, pos, strict_mode) {
-  if (!IS_FUNCTION(fun)) {
+  if (!IS_FUNCTION(fun) && !IS_NUMBER(fun)) {
     throw MakeTypeError(kCallSiteExpectsFunction, typeof fun);
   }
 
   if (IS_UNDEFINED(new.target)) {
     return new CallSite(receiver, fun, pos, strict_mode);
   }
 
-  SET_PRIVATE(this, callSiteReceiverSymbol, receiver);
-  SET_PRIVATE(this, callSiteFunctionSymbol, fun);
+  if (IS_FUNCTION(fun)) {
+    SET_PRIVATE(this, callSiteReceiverSymbol, receiver);
+    SET_PRIVATE(this, callSiteFunctionSymbol, fun);
+  } else {
+    SET_PRIVATE(this, callSiteWasmObjectSymbol, receiver);
+    SET_PRIVATE(this, callSiteWasmFunctionIndexSymbol, TO_UINT32(fun));
+  }
   SET_PRIVATE(this, callSitePositionSymbol, TO_INT32(pos));
   SET_PRIVATE(this, callSiteStrictSymbol, TO_BOOLEAN(strict_mode));
 }
 
 function CheckCallSite(obj, name) {
-  if (!IS_RECEIVER(obj) || !HAS_PRIVATE(obj, callSiteFunctionSymbol)) {
+  if (!IS_RECEIVER(obj) || !HAS_PRIVATE(obj, callSitePositionSymbol)) {
     throw MakeTypeError(kCallSiteMethod, name);
   }
 }
 
 function CallSiteGetThis() {
   CheckCallSite(this, "getThis");
   return GET_PRIVATE(this, callSiteStrictSymbol)
       ? UNDEFINED : GET_PRIVATE(this, callSiteReceiverSymbol);
 }
 
@@ skipping 30 matching lines @@
 }
 
 function CallSiteGetScriptNameOrSourceURL() {
   CheckCallSite(this, "getScriptNameOrSourceURL");
   return %CallSiteGetScriptNameOrSourceUrlRT(this);
 }
 
 function CallSiteGetFunctionName() {
   // See if the function knows its own name
   CheckCallSite(this, "getFunctionName");
+  if (HAS_PRIVATE(this, callSiteWasmObjectSymbol)) {
+    var wasm = GET_PRIVATE(this, callSiteWasmObjectSymbol);
+    var func_index = GET_PRIVATE(this, callSiteWasmFunctionIndexSymbol);
+    return IS_UNDEFINED(wasm) ? "<WASM>" :
+      IS_STRING(wasm) ? wasm : %WasmGetFunctionName(wasm, func_index);
+  }
   return %CallSiteGetFunctionNameRT(this);
 }
 
 function CallSiteGetMethodName() {
   // See if we can find a unique property on the receiver that holds
   // this function.
   CheckCallSite(this, "getMethodName");
   return %CallSiteGetMethodNameRT(this);
 }
 
@@ skipping 15 matching lines @@
 function CallSiteIsNative() {
   CheckCallSite(this, "isNative");
   return %CallSiteIsNativeRT(this);
 }
 
 function CallSiteIsConstructor() {
   CheckCallSite(this, "isConstructor");
   return %CallSiteIsConstructorRT(this);
 }
 
+function CallSiteIsWasm() {
+  CheckCallSite(this, "isWasm");
+  return HAS_PRIVATE(this, callSiteWasmObjectSymbol);
+}
+
+function CallSiteGetWasmObject() {
+  CheckCallSite(this, "getWasmObject");
+  return GET_PRIVATE(this, callSiteWasmObjectSymbol);
+}
+
+function CallSiteGetWasmFunctionIndex() {
+  CheckCallSite(this, "getWasmFunctionIndex");
+  return GET_PRIVATE(this, callSiteWasmFunctionIndexSymbol);
+}
+
 function CallSiteToString() {
+  if (this.isWasm()) {
+    return this.getFunctionName() + " (<WASM>:" + this.getPosition() + ")";
+  }
+
   var fileName;
   var fileLocation = "";
   if (this.isNative()) {
     fileLocation = "native";
   } else {
     fileName = this.getScriptNameOrSourceURL();
     if (!fileName && this.isEval()) {
       fileLocation = this.getEvalOrigin();
       fileLocation += ", ";  // Expecting source position to follow.
     }
@@ skipping 60 matching lines @@
   "getScriptNameOrSourceURL", CallSiteGetScriptNameOrSourceURL,
   "getFunction", CallSiteGetFunction,
   "getFunctionName", CallSiteGetFunctionName,
   "getMethodName", CallSiteGetMethodName,
   "getFileName", CallSiteGetFileName,
   "getLineNumber", CallSiteGetLineNumber,
   "getColumnNumber", CallSiteGetColumnNumber,
   "isNative", CallSiteIsNative,
   "getPosition", CallSiteGetPosition,
   "isConstructor", CallSiteIsConstructor,
+  "isWasm", CallSiteIsWasm,
+  "getWasmObject", CallSiteGetWasmObject,
+  "getWasmFunctionIndex", CallSiteGetWasmFunctionIndex,
   "toString", CallSiteToString
 ]);
 
 
 function FormatEvalOrigin(script) {
   var sourceURL = script.nameOrSourceURL();
   if (sourceURL) {
     return sourceURL;
   }
 
@@ skipping 44 matching lines @@
 
 
 function GetStackFrames(raw_stack) {
   var frames = new InternalArray();
   var sloppy_frames = raw_stack[0];
   for (var i = 1; i < raw_stack.length; i += 4) {
     var recv = raw_stack[i];
     var fun = raw_stack[i + 1];
     var code = raw_stack[i + 2];
     var pc = raw_stack[i + 3];
-    var pos = %_IsSmi(code) ? code : %FunctionGetPositionForOffset(code, pc);
+    var pos = %FunctionGetPositionForOffset(code, pc);
     sloppy_frames--;
     frames.push(new CallSite(recv, fun, pos, (sloppy_frames < 0)));
   }
   return frames;
 }
 
 
 // Flag to prevent recursive call of Error.prepareStackTrace.
 var formatting_custom_stack_trace = false;
 
@@ skipping 202 matching lines @@
 utils.Export(function(to) {
   to.ErrorToString = ErrorToString;
   to.MakeError = MakeError;
   to.MakeRangeError = MakeRangeError;
   to.MakeSyntaxError = MakeSyntaxError;
   to.MakeTypeError = MakeTypeError;
   to.MakeURIError = MakeURIError;
 });
 
 });