[wasm] Make wasm info available on the stack trace

src/frames.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/frames.h"
 
 #include <sstream>
 
 #include "src/ast/ast.h"
 #include "src/ast/scopeinfo.h"
 #include "src/base/bits.h"
 #include "src/deoptimizer.h"
 #include "src/frames-inl.h"
 #include "src/full-codegen/full-codegen.h"
 #include "src/register-configuration.h"
 #include "src/safepoint-table.h"
 #include "src/string-stream.h"
 #include "src/vm-state-inl.h"
+#include "src/wasm/wasm-module.h"
 
 namespace v8 {
 namespace internal {
 
 ReturnAddressLocationResolver
     StackFrame::return_address_location_resolver_ = NULL;
 
 
 // Iterator that supports traversing the stack handlers of a
 // particular frame. Needs to know the top of the handler chain.
@@ skipping 581 matching lines @@
   state->fp = fp;
   state->pc_address = ResolveReturnAddressLocation(
       reinterpret_cast<Address*>(sp - 1 * kPCOnStackSize));
   // The constant pool recorded in the exit frame is not associated
   // with the pc in this state (the return address into a C entry
   // stub).  ComputeCallerState will retrieve the constant pool
   // together with the associated caller pc.
   state->constant_pool_address = NULL;
 }
 
-void StandardFrame::Summarize(List<FrameSummary>* functions,
-                              FrameSummary::Mode mode) const {
-  DCHECK(functions->length() == 0);
-  // default implementation: no summary added
-}
-
-JSFunction* StandardFrame::function() const {
-  // this default implementation is overridden by JS and WASM frames
-  return nullptr;
-}
-
-Object* StandardFrame::receiver() const {
-  return isolate()->heap()->undefined_value();
-}
-
 Address StandardFrame::GetExpressionAddress(int n) const {
   const int offset = StandardFrameConstants::kExpressionsOffset;
   return fp() + offset - n * kPointerSize;
 }
 
 Address InterpretedFrame::GetExpressionAddress(int n) const {
   const int offset = InterpreterFrameConstants::kExpressionsOffset;
   return fp() + offset - n * kPointerSize;
 }
 
@@ skipping 690 matching lines @@
 
 void WasmFrame::Print(StringStream* accumulator, PrintMode mode,
                       int index) const {
   accumulator->Add("wasm frame");
 }
 
 Code* WasmFrame::unchecked_code() const {
   return static_cast<Code*>(isolate()->FindCodeObject(pc()));
 }
 
-JSFunction* WasmFrame::function() const {
-  // TODO(clemensh): generate the right JSFunctions once per wasm function and
-  // cache them
-  Factory* factory = isolate()->factory();
-  Handle<JSFunction> fun =
-      factory->NewFunction(factory->NewStringFromAsciiChecked("<WASM>"));
-  return *fun;
-}
-
-void WasmFrame::Summarize(List<FrameSummary>* functions,
-                          FrameSummary::Mode mode) const {
-  DCHECK(functions->length() == 0);
-  Code* code = LookupCode();
-  int offset = static_cast<int>(pc() - code->instruction_start());
-  AbstractCode* abstract_code = AbstractCode::cast(code);
-  Handle<JSFunction> fun(function(), isolate());
-  FrameSummary summary(receiver(), *fun, abstract_code, offset, false);
-  functions->Add(summary);
-}
-
 void WasmFrame::Iterate(ObjectVisitor* v) const { IterateCompiledFrame(v); }
 
 Address WasmFrame::GetCallerStackPointer() const {
   return fp() + ExitFrameConstants::kCallerSPOffset;
 }
 
+Object* WasmFrame::wasm_obj() {
+  FixedArray* deopt_data = LookupCode()->deoptimization_data();
+  DCHECK(deopt_data->length() == 2);
+  return deopt_data->get(0);
+}
+
+uint32_t WasmFrame::function_index() {
+  FixedArray* deopt_data = LookupCode()->deoptimization_data();
+  DCHECK(deopt_data->length() == 2);
+  Object* func_index_obj = deopt_data->get(1);
+  if (func_index_obj->IsUndefined()) return static_cast<uint32_t>(-1);
+  if (func_index_obj->IsSmi()) return Smi::cast(func_index_obj)->value();
+  DCHECK(func_index_obj->IsHeapNumber());
+  uint32_t val = static_cast<uint32_t>(-1);
+  func_index_obj->ToUint32(&val);
+  DCHECK(val != static_cast<uint32_t>(-1));
+  return val;
+}
+
+Object* WasmFrame::function_name() {
+  Object* wasm_obj_or_string = wasm_obj();

[Yang, 2016/05/04 19:02:21]

is the name of this variable still accurate?

[Clemens Hammacher, 2016/05/05 12:29:16]

No, sorry. Done.

+  if (wasm_obj_or_string->IsUndefined()) return wasm_obj_or_string;

[Yang, 2016/05/04 19:02:22]

I'm curious, in which case would wasm_obj() return undefined?

[Clemens Hammacher, 2016/05/05 12:29:16]

Just in the tests. Where it was string or undefined before, depending on whether
a name was set.

+  Handle<JSObject> wasm = handle(JSObject::cast(wasm_obj_or_string));
+  return *wasm::GetWasmFunctionName(wasm, function_index());
+}
+
 namespace {
 
 
 void PrintFunctionSource(StringStream* accumulator, SharedFunctionInfo* shared,
                          Code* code) {
   if (FLAG_max_stack_trace_source_length != 0 && code != NULL) {
     std::ostringstream os;
     os << "--------- s o u r c e   c o d e ---------\n"
        << SourceCodeOf(shared, FLAG_max_stack_trace_source_length)
        << "\n-----------------------------------------\n";
@@ skipping 417 matching lines @@
   for (StackFrameIterator it(isolate); !it.done(); it.Advance()) {
     StackFrame* frame = AllocateFrameCopy(it.frame(), zone);
     list.Add(frame, zone);
   }
   return list.ToVector();
 }
 
 
 }  // namespace internal
 }  // namespace v8