v8: emit backtrace when trap happens.

src/v8/v8.cc

@@ -16,9 +16,10 @@
 #include "include/proxy-wasm/v8.h"
 
 #include <cassert>
-
+#include <iomanip>
 #include <memory>
 #include <optional>
+#include <sstream>
 #include <utility>
 #include <vector>
 
@@ -84,6 +85,7 @@ class V8 : public WasmVm {
 #undef _GET_MODULE_FUNCTION
 
 private:
+  std::string getFailMessage(std::string_view function_name, wasm::own<wasm::Trap> trap);
   wasm::vec<byte_t> getStrippedSource();
 
   template <typename... Args>
@@ -112,6 +114,8 @@ class V8 : public WasmVm {
 
   absl::flat_hash_map<std::string, FuncDataPtr> host_functions_;
   absl::flat_hash_map<std::string, wasm::own<wasm::Func>> module_functions_;
+
+  absl::flat_hash_map<uint32_t, std::string> function_names_index_;
 };
 
 // Helper functions.
@@ -263,6 +267,32 @@ bool V8::load(const std::string &code, bool allow_precompiled) {
     assert((shared_module_ != nullptr));
   }
 
+  // build function index -> function name map for backtrace
+  // https://webassembly.github.io/spec/core/appendix/custom.html#binary-namesubsection
+  auto name_section = getCustomSection("name");
+  if (name_section.size()) {
+    const byte_t *pos = name_section.data();
+    const byte_t *end = name_section.data() + name_section.size();
+
+    // module name subsection (id=0) is currently unimplemented in LLVM but we handle the
+    // case just in case
+    if (*pos == 0) {
+      pos++;
+      pos += parseVarint(pos, end);
+    }
+
+    if (*pos == 1) {
+      pos++;
+      parseVarint(pos, end); // skip subsection size
+      const uint32_t namemap_vector_size = parseVarint(pos, end);
+      for (auto i = 0; i < namemap_vector_size; i++) {
+        const uint32_t func_index = parseVarint(pos, end);
+        const uint32_t func_name_size = parseVarint(pos, end);
+        function_names_index_.insert({func_index, std::string(pos, func_name_size)});
+        pos += func_name_size;
+      }
+    }
+  }
   return module_ != nullptr;
 }
 
@@ -274,7 +304,7 @@ std::unique_ptr<WasmVm> V8::clone() {
   clone->store_ = wasm::Store::make(engine());
 
   clone->module_ = wasm::Module::obtain(clone->store_.get(), shared_module_.get());
-
+  clone->function_names_index_ = function_names_index_;
   return clone;
 }
 
@@ -500,6 +530,7 @@ bool V8::link(std::string_view debug_name) {
     } break;
     }
   }
+
   return !isFailed();
 }
 
@@ -618,8 +649,7 @@ void V8::getModuleFunctionImpl(std::string_view function_name,
     SaveRestoreContext saved_context(context);
     auto trap = func->call(params, nullptr);
     if (trap) {
-      fail(FailState::RuntimeError, "Function: " + std::string(function_name) + " failed: " +
-                                        std::string(trap->message().get(), trap->message().size()));
+      fail(FailState::RuntimeError, getFailMessage(std::string(function_name), std::move(trap)));
     }
   };
 }
@@ -651,15 +681,47 @@ void V8::getModuleFunctionImpl(std::string_view function_name,
     SaveRestoreContext saved_context(context);
     auto trap = func->call(params, results);
     if (trap) {
-      fail(FailState::RuntimeError, "Function: " + std::string(function_name) + " failed: " +
-                                        std::string(trap->message().get(), trap->message().size()));
+      fail(FailState::RuntimeError, getFailMessage(std::string(function_name), std::move(trap)));
       return R{};
     }
     R rvalue = results[0].get<typename ConvertWordTypeToUint32<R>::type>();
     return rvalue;
   };
 }
 
+std::string V8::getFailMessage(std::string_view function_name, wasm::own<wasm::Trap> trap) {
+  auto message = "Function: " + std::string(function_name) + " failed: ";
+  message += std::string(trap->message().get(), trap->message().size());
+
+  if (function_names_index_.empty()) {
+    return message;
+  }
+
+  auto trace = trap->trace();
+  message += "\nProxy-Wasm plugin in-VM backtrace:\n";
+  for (size_t i = 0; i < trace.size(); ++i) {
+    auto frame = trace[i].get();
+    std::ostringstream oss;
+    oss << std::setw(3) << std::setfill(' ') << std::to_string(i);
+    message += oss.str() + ": ";
+
+    std::stringstream address;
+    address << std::hex << frame->module_offset();
+    message += " 0x" + address.str() + " - ";
+
+    auto func_index = frame->func_index();
+    auto it = function_names_index_.find(func_index);
+    std::string function_name;
+    if (it != function_names_index_.end()) {
+      function_name = it->second;
+    } else {
+      function_name = "unknown(function index:" + std::to_string(func_index) + ")";
+    }
+    message += function_name + "\n";
+  }
+  return message;
+}
+
 } // namespace
 
 std::unique_ptr<WasmVm> createV8Vm() { return std::make_unique<V8>(); }