[wasm] Implement {Compile,Runtime}Error; fix traps from start function

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 547 matching lines @@
        i < module->functions.size(); ++i) {
     const WasmFunction& func = module->functions[i];
     if (func.imported) continue;  // Imports are compiled at instantiation time.
 
     WasmName str = module->GetName(func.name_offset, func.name_length);
     Handle<Code> code = Handle<Code>::null();
     // Compile the function.
     code = compiler::WasmCompilationUnit::CompileWasmFunction(
         thrower, isolate, module_env, &func);
     if (code.is_null()) {
-      thrower->Error("Compilation of #%d:%.*s failed.", i, str.length(),
-                     str.start());
+      thrower->CompileError("Compilation of #%d:%.*s failed.", i, str.length(),
+                            str.start());
       break;
     }
       // Install the code into the linker table.
     functions[i] = code;
   }
 }
 
 void PatchDirectCalls(Handle<FixedArray> old_functions,
                       Handle<FixedArray> new_functions, int start) {
   DCHECK_EQ(new_functions->length(), old_functions->length());
@@ skipping 681 matching lines @@
     // Set up the globals for the new instance.
     //--------------------------------------------------------------------------
     MaybeHandle<JSArrayBuffer> old_globals;
     MaybeHandle<JSArrayBuffer> globals;
     uint32_t globals_size = compiled_module_->globals_size();
     if (globals_size > 0) {
       Handle<JSArrayBuffer> global_buffer =
           NewArrayBuffer(isolate_, globals_size);
       globals = global_buffer;
       if (globals.is_null()) {
-        thrower_->Error("Out of memory: wasm globals");
+        thrower_->RangeError("Out of memory: wasm globals");
         return nothing;
       }
       Address old_address = owner.is_null()
                                 ? nullptr
                                 : GetGlobalStartAddressFromCodeTemplate(
                                       *factory->undefined_value(),
                                       JSObject::cast(*owner.ToHandleChecked()));
       RelocateGlobals(instance, old_address,
                       static_cast<Address>(global_buffer->backing_store()));
       instance->SetInternalField(kWasmGlobalsArrayBuffer, *global_buffer);
@@ skipping 136 matching lines @@
         }
         module_object_->SetInternalField(0, *compiled_module_);
         instance->SetInternalField(kWasmCompiledModule, *compiled_module_);
         compiled_module_->set_weak_owning_instance(link_to_owning_instance);
         GlobalHandles::MakeWeak(global_handle.location(),
                                 global_handle.location(), &InstanceFinalizer,
                                 v8::WeakCallbackType::kFinalizer);
       }
     }
 
+    DCHECK(wasm::IsWasmObject(*instance));
+
     //--------------------------------------------------------------------------
     // Run the start function if one was specified.
     //--------------------------------------------------------------------------
     if (compiled_module_->has_startup_function()) {
       Handle<FixedArray> startup_data = compiled_module_->startup_function();
       HandleScope scope(isolate_);
       int32_t start_index =
           startup_data->GetValueChecked<Smi>(isolate_, kExportIndex)->value();
       Handle<Code> startup_code =
           code_table->GetValueChecked<Code>(isolate_, start_index);
       int arity = Smi::cast(startup_data->get(kExportArity))->value();
       MaybeHandle<ByteArray> startup_signature =
           startup_data->GetValue<ByteArray>(isolate_, kExportedSignature);
       Handle<JSFunction> startup_fct = WrapExportCodeAsJSFunction(
           isolate_, startup_code, factory->InternalizeUtf8String("start"),
           arity, startup_signature, instance);
       RecordStats(isolate_, *startup_code);
       // Call the JS function.
       Handle<Object> undefined = factory->undefined_value();
       MaybeHandle<Object> retval =
           Execution::Call(isolate_, startup_fct, undefined, 0, nullptr);
 
       if (retval.is_null()) {
-        thrower_->Error("WASM.instantiateModule(): start function failed");
+        DCHECK(isolate_->has_pending_exception());
+        isolate_->OptionalRescheduleException(false);
         // It's unfortunate that the new instance is already linked in the
         // chain. However, we need to set up everything before executing the
         // start function, such that stack trace information can be generated
         // correctly already in the start function.
         return nothing;
       }
     }
 
-    DCHECK(wasm::IsWasmObject(*instance));
-
+    DCHECK(!isolate_->has_pending_exception());
     TRACE("Finishing instance %d\n", compiled_module_->instance_id());
     TRACE_CHAIN(WasmCompiledModule::cast(module_object_->GetInternalField(0)));
     return instance;
   }
 
  private:
   Isolate* isolate_;
   ErrorThrower* thrower_;
   Handle<JSObject> module_object_;
   Handle<JSReceiver> ffi_;
   Handle<JSArrayBuffer> memory_;
   Handle<WasmCompiledModule> compiled_module_;
 
   // Helper routine to print out errors with imports (FFI).
   MaybeHandle<JSFunction> ReportFFIError(const char* error, uint32_t index,
                                          Handle<String> module_name,
                                          MaybeHandle<String> function_name) {
     Handle<String> function_name_handle;
     if (function_name.ToHandle(&function_name_handle)) {
-      thrower_->Error("Import #%d module=\"%.*s\" function=\"%.*s\" error: %s",
-                      index, module_name->length(),
-                      module_name->ToCString().get(),
-                      function_name_handle->length(),
-                      function_name_handle->ToCString().get(), error);
+      thrower_->TypeError(
+          "Import #%d module=\"%.*s\" function=\"%.*s\" error: %s", index,
+          module_name->length(), module_name->ToCString().get(),
+          function_name_handle->length(),
+          function_name_handle->ToCString().get(), error);
     } else {
-      thrower_->Error("Import #%d module=\"%.*s\" error: %s", index,
-                      module_name->length(), module_name->ToCString().get(),
-                      error);
+      thrower_->TypeError("Import #%d module=\"%.*s\" error: %s", index,
+                          module_name->length(), module_name->ToCString().get(),
+                          error);
     }
-    thrower_->Error("Import ");
+    thrower_->TypeError("Import ");
     return MaybeHandle<JSFunction>();
   }
 
   // Look up an import value in the {ffi_} object.
   MaybeHandle<Object> LookupImport(uint32_t index, Handle<String> module_name,
                                    MaybeHandle<String> import_name) {
     if (ffi_.is_null()) {
       return ReportFFIError("FFI is not an object", index, module_name,
                             import_name);
     }
@@ skipping 264 matching lines @@
         if (type == kLocalI64 || type == kLocalF64) size = sizeof(double);
         memcpy(raw_buffer_ptr(globals, offset),
                raw_buffer_ptr(globals, old_offset), size);
       }
     }
   }
 
   // Allocate memory for a module instance as a new JSArrayBuffer.
   Handle<JSArrayBuffer> AllocateMemory(uint32_t min_mem_pages) {
     if (min_mem_pages > WasmModule::kMaxMemPages) {
-      thrower_->Error("Out of memory: wasm memory too large");
+      thrower_->RangeError("Out of memory: wasm memory too large");
       return Handle<JSArrayBuffer>::null();
     }
     Handle<JSArrayBuffer> mem_buffer =
         NewArrayBuffer(isolate_, min_mem_pages * WasmModule::kPageSize);
 
     if (mem_buffer.is_null()) {
-      thrower_->Error("Out of memory: wasm memory");
+      thrower_->RangeError("Out of memory: wasm memory");
     }
     return mem_buffer;
   }
 
   // Process the exports, creating wrappers for functions, tables, memories,
   // and globals.
   void ProcessExports(MaybeHandle<JSArrayBuffer> globals,
                       Handle<FixedArray> code_table,
                       Handle<JSObject> instance) {
     if (!compiled_module_->has_exports()) return;
@@ skipping 80 matching lines @@
           break;
         }
         default:
           UNREACHABLE();
           break;
       }
 
       v8::Maybe<bool> status = JSReceiver::DefineOwnProperty(
           isolate_, exports_object, name, &desc, Object::THROW_ON_ERROR);
       if (!status.IsJust()) {
-        thrower_->Error("export of %.*s failed.", name->length(),
-                        name->ToCString().get());
+        thrower_->TypeError("export of %.*s failed.", name->length(),
+                            name->ToCString().get());
         return;
       }
     }
   }
 };
 
 // Instantiates a WASM module, creating a WebAssembly.Instance from a
 // WebAssembly.Module.
 MaybeHandle<JSObject> WasmModule::Instantiate(Isolate* isolate,
                                               ErrorThrower* thrower,
@@ skipping 263 matching lines @@
     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);
+    thrower->CompileFailed("Wasm decoding failed", result);
     return nothing;
   }
   MaybeHandle<WasmCompiledModule> maybe_compiled_module =
       decoded_module->CompileFunctions(isolate, thrower);
   if (maybe_compiled_module.is_null()) return nothing;
   Handle<WasmCompiledModule> compiled_module =
       maybe_compiled_module.ToHandleChecked();
 
   DCHECK_EQ(origin == kAsmJsOrigin, !asm_js_script.is_null());
   DCHECK(!compiled_module->has_asm_js_script());
@@ skipping 146 matching lines @@
 }
 
 void testing::ValidateOrphanedInstance(Isolate* isolate,
                                        Handle<JSObject> instance) {
   DisallowHeapAllocation no_gc;
   CHECK(IsWasmObject(*instance));
   WasmCompiledModule* compiled_module = GetCompiledModule(*instance);
   CHECK(compiled_module->has_weak_module_object());
   CHECK(compiled_module->ptr_to_weak_module_object()->cleared());
 }