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

src/wasm/wasm-module.cc

 // Copyright 2015 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 <memory>
 
 #include "src/base/atomic-utils.h"
 #include "src/code-stubs.h"
 
 #include "src/macro-assembler.h"
@@ skipping 767 matching lines @@
     case kStartSectionCode:
       return "Start";
     case kCodeSectionCode:
       return "Code";
     case kElementSectionCode:
       return "Element";
     case kDataSectionCode:
       return "Data";
     case kNameSectionCode:
       return "Name";
+    case kAsmOffsetsSectionCode:
+      return "AsmOffsets";
     default:
       return "<unknown>";
   }
 }
 
 std::ostream& operator<<(std::ostream& os, const WasmModule& module) {
   os << "WASM module with ";
   os << (module.min_mem_pages * module.kPageSize) << " min mem";
   os << (module.max_mem_pages * module.kPageSize) << " max mem";
   os << module.functions.size() << " functions";
@@ skipping 1197 matching lines @@
       !(mem->IsUndefined(isolate) || mem->IsJSArrayBuffer()) ||
       !WasmCompiledModule::IsWasmCompiledModule(
           obj->GetInternalField(kWasmCompiledModule))) {
     return false;
   }
 
   // All checks passed.
   return true;
 }
 
+bool WasmIsAsm(Object* wasm, Isolate* isolate) {
+  if (wasm->IsUndefined(isolate)) return false;
+  DCHECK(IsWasmObject(wasm));
+  Object* compiled_module =
+      JSObject::cast(wasm)->GetInternalField(kWasmCompiledModule);
+  return WasmCompiledModule::cast(compiled_module)->has_asm_js_script();
+}
+
+Handle<Script> GetAsmWasmScript(Handle<JSObject> wasm) {
+  DCHECK(IsWasmObject(*wasm));
+  Object* compiled_module =
+      JSObject::cast(*wasm)->GetInternalField(kWasmCompiledModule);
+  return WasmCompiledModule::cast(compiled_module)->asm_js_script();
+}
+
+int GetAsmWasmSourcePosition(Handle<JSObject> wasm, int func_index,
+                             int byte_offset) {
+  return WasmDebugInfo::GetAsmJsSourcePosition(GetDebugInfo(wasm), func_index,
+                                               byte_offset);
+}
+
 Handle<SeqOneByteString> GetWasmBytes(Handle<JSObject> wasm) {
   DCHECK(IsWasmObject(*wasm));
   Object* compiled_module = wasm->GetInternalField(kWasmCompiledModule);
   return WasmCompiledModule::cast(compiled_module)->module_bytes();
 }
 
 Handle<WasmDebugInfo> GetDebugInfo(Handle<JSObject> wasm) {
   Handle<Object> info(wasm->GetInternalField(kWasmDebugInfo),
                       wasm->GetIsolate());
   if (!info->IsUndefined(wasm->GetIsolate()))
@@ skipping 97 matching lines @@
   module_obj->SetInternalField(0, *compiled_module);
   if (origin == ModuleOrigin::kWasmOrigin) {
     Handle<Symbol> module_sym(isolate->native_context()->wasm_module_sym());
     Object::SetProperty(module_obj, module_sym, module_obj, STRICT).Check();
   }
   Handle<WeakCell> link_to_module = isolate->factory()->NewWeakCell(module_obj);
   compiled_module->set_weak_module_object(link_to_module);
   return module_obj;
 }
 
-MaybeHandle<JSObject> CreateModuleObjectFromBytes(Isolate* isolate,
-                                                  const byte* start,
-                                                  const byte* end,
-                                                  ErrorThrower* thrower,
-                                                  ModuleOrigin origin) {
+// TODO(clemensh): origin can be inferred from asm_js_script; remove it.
+MaybeHandle<JSObject> CreateModuleObjectFromBytes(
+    Isolate* isolate, const byte* start, const byte* end, ErrorThrower* thrower,
+    ModuleOrigin origin, Handle<Script> asm_js_script) {
   MaybeHandle<JSObject> nothing;
   Zone zone(isolate->allocator());
   ModuleResult result =
       DecodeWasmModule(isolate, &zone, start, end, false, origin);
   std::unique_ptr<const WasmModule> decoded_module(result.val);
   if (result.failed()) {
     thrower->Failed("Wasm decoding failed", result);
     return nothing;
   }
-  MaybeHandle<WasmCompiledModule> compiled_module =
+  MaybeHandle<WasmCompiledModule> maybe_compiled_module =
       decoded_module->CompileFunctions(isolate, thrower);
-  if (compiled_module.is_null()) return nothing;
+  if (maybe_compiled_module.is_null()) return nothing;
+  Handle<WasmCompiledModule> compiled_module =
+      maybe_compiled_module.ToHandleChecked();
 
-  return CreateCompiledModuleObject(isolate, compiled_module.ToHandleChecked(),
-                                    origin);
+  DCHECK_EQ(origin == kAsmJsOrigin, !asm_js_script.is_null());
+  DCHECK(!compiled_module->has_asm_js_script());
+  if (origin == kAsmJsOrigin) {
+    compiled_module->set_asm_js_script(asm_js_script);
+  }
+
+  return CreateCompiledModuleObject(isolate, compiled_module, origin);
 }
 
 bool ValidateModuleBytes(Isolate* isolate, const byte* start, const byte* end,
                          ErrorThrower* thrower, ModuleOrigin origin) {
   Zone zone(isolate->allocator());
   ModuleResult result =
       DecodeWasmModule(isolate, &zone, start, end, false, origin);
   if (result.ok()) {
     DCHECK_NOT_NULL(result.val);
     delete result.val;
@@ skipping 126 matching lines @@
   WasmCompiledModule* compiled_module =
       WasmCompiledModule::cast(instance->GetInternalField(kWasmCompiledModule));
   CHECK(compiled_module->has_weak_module_object());
   CHECK(compiled_module->ptr_to_weak_module_object()->cleared());
 }
 
 }  // namespace testing
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8