[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 642 matching lines @@
                                code->instruction_size());
       }
     }
   }
   compiled_module->reset_heap();
 }
 
 static void InstanceFinalizer(const v8::WeakCallbackInfo<void>& data) {
   JSObject** p = reinterpret_cast<JSObject**>(data.GetParameter());
   JSObject* owner = *p;
-  WasmCompiledModule* compiled_module =
-      WasmCompiledModule::cast(owner->GetInternalField(kWasmCompiledModule));
+  WasmCompiledModule* compiled_module = GetCompiledModule(owner);
   TRACE("Finalizing %d {\n", compiled_module->instance_id());
   Isolate* isolate = reinterpret_cast<Isolate*>(data.GetIsolate());
   DCHECK(compiled_module->has_weak_module_object());
   WeakCell* weak_module_obj = compiled_module->ptr_to_weak_module_object();
 
   // weak_module_obj may have been cleared, meaning the module object
   // was GC-ed. In that case, there won't be any new instances created,
   // and we don't need to maintain the links between instances.
   if (!weak_module_obj->cleared()) {
     JSObject* module_obj = JSObject::cast(weak_module_obj->value());
@@ skipping 179 matching lines @@
   DCHECK(deopt_data->length() == 2);
   Object* weak_link = deopt_data->get(0);
   if (!weak_link->IsWeakCell()) return nullptr;
   WeakCell* cell = WeakCell::cast(weak_link);
   return cell->value();
 }
 
 int GetNumImportedFunctions(Handle<JSObject> wasm_object) {
   // TODO(wasm): Cache this number if it ever becomes a performance problem.
   DCHECK(IsWasmObject(*wasm_object));
-  Object* compiled_module = wasm_object->GetInternalField(kWasmCompiledModule);
+  WasmCompiledModule* compiled_module = GetCompiledModule(*wasm_object);
   Handle<FixedArray> imports =
       WasmCompiledModule::cast(compiled_module)->imports();
   int num_imports = imports->length();
   int num_imported_functions = 0;
   for (int i = 0; i < num_imports; ++i) {
     FixedArray* encoded_import = FixedArray::cast(imports->get(i));
     int kind = Smi::cast(encoded_import->get(kImportKind))->value();
     if (kind == kExternalFunction) ++num_imported_functions;
   }
   return num_imported_functions;
@@ skipping 543 matching lines @@
       Handle<WeakCell> link_to_clone = factory->NewWeakCell(compiled_module_);
       Handle<WeakCell> link_to_owning_instance = factory->NewWeakCell(instance);
       MaybeHandle<WeakCell> link_to_original;
       MaybeHandle<WasmCompiledModule> original;
       if (!owner.is_null()) {
         // prepare the data needed for publishing in a chain, but don't link
         // just yet, because
         // we want all the publishing to happen free from GC interruptions, and
         // so we do it in
         // one GC-free scope afterwards.
-        original = handle(WasmCompiledModule::cast(
-            owner.ToHandleChecked()->GetInternalField(kWasmCompiledModule)));
+        original = handle(GetCompiledModule(*owner.ToHandleChecked()));
         link_to_original = factory->NewWeakCell(original.ToHandleChecked());
       }
       // Publish the new instance to the instances chain.
       {
         DisallowHeapAllocation no_gc;
         if (!link_to_original.is_null()) {
           compiled_module_->set_weak_next_instance(
               link_to_original.ToHandleChecked());
           original.ToHandleChecked()->set_weak_prev_instance(link_to_clone);
           compiled_module_->set_weak_module_object(
@@ skipping 511 matching lines @@
         WasmCompiledModule::cast(current->ptr_to_weak_next_instance()->value());
   }
   PrintF("\n");
 #endif
 }
 
 Handle<Object> GetWasmFunctionNameOrNull(Isolate* isolate, Handle<Object> wasm,
                                          uint32_t func_index) {
   if (!wasm->IsUndefined(isolate)) {
     DCHECK(IsWasmObject(*wasm));
-    WasmCompiledModule* compiled_module = WasmCompiledModule::cast(
-        Handle<JSObject>::cast(wasm)->GetInternalField(kWasmCompiledModule));
+    WasmCompiledModule* compiled_module =
+        GetCompiledModule(JSObject::cast(*wasm));
     Handle<ByteArray> func_names = compiled_module->function_names();
     // TODO(clemens): Extract this from the module bytes; skip whole function
     // name table.
     Handle<Object> name;
     if (GetWasmFunctionNameFromTable(func_names, func_index).ToHandle(&name)) {
       return name;
     }
   }
   return isolate->factory()->null_value();
 }
@@ skipping 22 matching lines @@
       !(mem->IsUndefined(isolate) || mem->IsJSArrayBuffer()) ||
       !WasmCompiledModule::IsWasmCompiledModule(
           obj->GetInternalField(kWasmCompiledModule))) {
     return false;
   }
 
   // All checks passed.
   return true;
 }
 
+WasmCompiledModule* GetCompiledModule(JSObject* wasm) {
+  return WasmCompiledModule::cast(wasm->GetInternalField(kWasmCompiledModule));
+}
+
+bool WasmIsAsmJs(Object* wasm, Isolate* isolate) {
+  if (wasm->IsUndefined(isolate)) return false;
+  DCHECK(IsWasmObject(wasm));
+  WasmCompiledModule* compiled_module = GetCompiledModule(JSObject::cast(wasm));
+  return compiled_module->has_asm_js_script();
+}
+
+Handle<Script> GetAsmWasmScript(Handle<JSObject> wasm) {
+  DCHECK(IsWasmObject(*wasm));
+  WasmCompiledModule* compiled_module = GetCompiledModule(*wasm);
+  return 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();
+  WasmCompiledModule* compiled_module = GetCompiledModule(*wasm);
+  return compiled_module->module_bytes();
 }
 
 Handle<WasmDebugInfo> GetDebugInfo(Handle<JSObject> wasm) {
   Handle<Object> info(wasm->GetInternalField(kWasmDebugInfo),
                       wasm->GetIsolate());
   if (!info->IsUndefined(wasm->GetIsolate()))
     return Handle<WasmDebugInfo>::cast(info);
   Handle<WasmDebugInfo> new_info = WasmDebugInfo::New(wasm);
   wasm->SetInternalField(kWasmDebugInfo, *new_info);
   return new_info;
@@ skipping 62 matching lines @@
   for (uint32_t i = max_size; i < max_size + table_size; ++i) {
     int index = Smi::cast(table->get(static_cast<int>(i)))->value();
     DCHECK_GE(index, 0);
     DCHECK_LT(static_cast<size_t>(index), code_table->size());
     table->set(static_cast<int>(i), *(*code_table)[index]);
   }
 }
 
 int GetNumberOfFunctions(Handle<JSObject> wasm) {
   DCHECK(IsWasmObject(*wasm));
-  WasmCompiledModule* compiled_module =
-      WasmCompiledModule::cast(wasm->GetInternalField(kWasmCompiledModule));
+  WasmCompiledModule* compiled_module = GetCompiledModule(*wasm);
   ByteArray* func_names_arr = compiled_module->ptr_to_function_names();
   // TODO(clemensh): this looks inside an array constructed elsewhere. Refactor.
   return func_names_arr->get_int(0);
 }
 
 Handle<JSObject> CreateCompiledModuleObject(
     Isolate* isolate, Handle<WasmCompiledModule> compiled_module,
     ModuleOrigin origin) {
   Handle<JSObject> module_obj;
   if (origin == ModuleOrigin::kWasmOrigin) {
     Handle<JSFunction> module_cons(
         isolate->native_context()->wasm_module_constructor());
     module_obj = isolate->factory()->NewJSObject(module_cons);
   } else {
     DCHECK(origin == ModuleOrigin::kAsmJsOrigin);
     Handle<Map> map = isolate->factory()->NewMap(
         JS_OBJECT_TYPE, JSObject::kHeaderSize + kPointerSize);
     module_obj = isolate->factory()->NewJSObjectFromMap(map, TENURED);
   }
   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,
+    const byte* asm_js_offset_tables_start,
+    const byte* asm_js_offset_tables_end) {
   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());
+  DCHECK(!compiled_module->has_asm_js_offset_tables());
+  if (origin == kAsmJsOrigin) {
+    compiled_module->set_asm_js_script(asm_js_script);
+    size_t offset_tables_len =
+        asm_js_offset_tables_end - asm_js_offset_tables_start;
+    DCHECK_GE(static_cast<size_t>(kMaxInt), offset_tables_len);
+    Handle<ByteArray> offset_tables =
+        isolate->factory()->NewByteArray(static_cast<int>(offset_tables_len));
+    memcpy(offset_tables->GetDataStartAddress(), asm_js_offset_tables_start,
+           offset_tables_len);
+    compiled_module->set_asm_js_offset_tables(offset_tables);
+  }
+
+  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;
     return true;
   }
   return false;
 }
 
 MaybeHandle<JSArrayBuffer> GetInstanceMemory(Isolate* isolate,
                                              Handle<JSObject> instance) {
   Object* mem = instance->GetInternalField(kWasmMemArrayBuffer);
   DCHECK(IsWasmObject(*instance));
   if (mem->IsUndefined(isolate)) return MaybeHandle<JSArrayBuffer>();
   return Handle<JSArrayBuffer>(JSArrayBuffer::cast(mem));
 }
 
 void SetInstanceMemory(Handle<JSObject> instance, JSArrayBuffer* buffer) {
   DisallowHeapAllocation no_gc;
   DCHECK(IsWasmObject(*instance));
   instance->SetInternalField(kWasmMemArrayBuffer, buffer);
-  WasmCompiledModule* module =
-      WasmCompiledModule::cast(instance->GetInternalField(kWasmCompiledModule));
-  module->set_ptr_to_heap(buffer);
+  WasmCompiledModule* compiled_module = GetCompiledModule(*instance);
+  compiled_module->set_ptr_to_heap(buffer);
 }
 
 int32_t GetInstanceMemorySize(Isolate* isolate, Handle<JSObject> instance) {
   MaybeHandle<JSArrayBuffer> maybe_mem_buffer =
       GetInstanceMemory(isolate, instance);
   Handle<JSArrayBuffer> buffer;
   if (!maybe_mem_buffer.ToHandle(&buffer)) {
     return 0;
   } else {
     return buffer->byte_length()->Number() / WasmModule::kPageSize;
@@ skipping 86 matching lines @@
   CHECK(compiled_module->has_weak_module_object());
   CHECK_EQ(compiled_module->ptr_to_weak_module_object()->value(), *module_obj);
   CHECK(!compiled_module->has_weak_prev_instance());
   CHECK(!compiled_module->has_weak_next_instance());
   CHECK(!compiled_module->has_weak_owning_instance());
 }
 
 void ValidateOrphanedInstance(Isolate* isolate, Handle<JSObject> instance) {
   DisallowHeapAllocation no_gc;
   CHECK(IsWasmObject(*instance));
-  WasmCompiledModule* compiled_module =
-      WasmCompiledModule::cast(instance->GetInternalField(kWasmCompiledModule));
+  WasmCompiledModule* compiled_module = GetCompiledModule(*instance);
   CHECK(compiled_module->has_weak_module_object());
   CHECK(compiled_module->ptr_to_weak_module_object()->cleared());
 }
 
 }  // namespace testing
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8