[promisehook] Implement PromiseHook

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/adapters.h"
 #include "src/base/atomic-utils.h"
 #include "src/code-stubs.h"
 #include "src/compiler/wasm-compiler.h"
@@ skipping 1374 matching lines @@
   Handle<JSObject> module_object_;
   Handle<JSReceiver> ffi_;
   Handle<JSArrayBuffer> memory_;
   Handle<JSArrayBuffer> globals_;
   Handle<WasmCompiledModule> compiled_module_;
   std::vector<TableInstance> table_instances_;
   std::vector<Handle<JSFunction>> js_wrappers_;
 
   // Helper routines to print out errors with imports.
   void ReportLinkError(const char* error, uint32_t index,
-                       Handle<String> module_name,
-                       Handle<String> import_name) {
+                       Handle<String> module_name, Handle<String> import_name) {
     thrower_->LinkError(
         "Import #%d module=\"%.*s\" function=\"%.*s\" error: %s", index,
         module_name->length(), module_name->ToCString().get(),
         import_name->length(), import_name->ToCString().get(), error);
   }
 
   MaybeHandle<Object> ReportTypeError(const char* error, uint32_t index,
                                       Handle<String> module_name) {
     thrower_->TypeError("Import #%d module=\"%.*s\" error: %s", index,
                         module_name->length(), module_name->ToCString().get(),
@@ skipping 17 matching lines @@
 
     Handle<Object> module = result.ToHandleChecked();
 
     // TODO(bradnelson): Making this conditional on non-empty names violates the
     // Wasm spec, but seems to be a hack intended for the asm-to-wasm pipeline.
     // We need to get rid of it.
     if (import_name->length() != 0) {
       // Look up the value in the module.
       if (!module->IsJSReceiver()) {
         return ReportTypeError("module is not an object or function", index,
-                             module_name);
+                               module_name);
       }
 
       result = Object::GetPropertyOrElement(module, import_name);
       if (result.is_null()) {
         ReportLinkError("import not found", index, module_name, import_name);
         return MaybeHandle<JSFunction>();
       }
     }
 
     return result;
@@ skipping 70 matching lines @@
   // functions.
   int ProcessImports(Handle<FixedArray> code_table,
                      Handle<WasmInstanceObject> instance) {
     int num_imported_functions = 0;
     int num_imported_tables = 0;
     for (int index = 0; index < static_cast<int>(module_->import_table.size());
          ++index) {
       WasmImport& import = module_->import_table[index];
 
       Handle<String> module_name;
-      MaybeHandle<String> maybe_module_name =
-          ExtractStringFromModuleBytes(isolate_, compiled_module_,
-                                       import.module_name_offset,
-                                       import.module_name_length);
+      MaybeHandle<String> maybe_module_name = ExtractStringFromModuleBytes(
+          isolate_, compiled_module_, import.module_name_offset,
+          import.module_name_length);
       if (!maybe_module_name.ToHandle(&module_name)) return -1;
 
       Handle<String> import_name;
-      MaybeHandle<String> maybe_import_name =
-          ExtractStringFromModuleBytes(isolate_, compiled_module_,
-                                       import.field_name_offset,
-                                       import.field_name_length);
+      MaybeHandle<String> maybe_import_name = ExtractStringFromModuleBytes(
+          isolate_, compiled_module_, import.field_name_offset,
+          import.field_name_length);
       if (!maybe_import_name.ToHandle(&import_name)) return -1;
 
       MaybeHandle<Object> result =
           LookupImport(index, module_name, import_name);
       if (thrower_->error()) return -1;
       Handle<Object> value = result.ToHandleChecked();
 
       switch (import.kind) {
         case kExternalFunction: {
           // Function imports must be callable.
           if (!value->IsCallable()) {
             ReportLinkError("function import requires a callable", index,
                             module_name, import_name);
             return -1;
           }
 
           Handle<Code> import_wrapper = CompileImportWrapper(
               isolate_, index, module_->functions[import.index].sig,
               Handle<JSReceiver>::cast(value), module_name, import_name,
               module_->origin);
           if (import_wrapper.is_null()) {
             ReportLinkError(
-                "imported function does not match the expected type",
-                index, module_name, import_name);
+                "imported function does not match the expected type", index,
+                module_name, import_name);
             return -1;
           }
           code_table->set(num_imported_functions, *import_wrapper);
           RecordStats(isolate_, *import_wrapper);
           num_imported_functions++;
           break;
         }
         case kExternalTable: {
           if (!WasmJs::IsWasmTableObject(isolate_, value)) {
             ReportLinkError("table import requires a WebAssembly.Table", index,
@@ skipping 53 matching lines @@
           auto memory = Handle<WasmMemoryObject>::cast(value);
           DCHECK(WasmJs::IsWasmMemoryObject(isolate_, memory));
           instance->set_memory_object(*memory);
           memory_ = Handle<JSArrayBuffer>(memory->get_buffer(), isolate_);
           break;
         }
         case kExternalGlobal: {
           // Global imports are converted to numbers and written into the
           // {globals_} array buffer.
           if (!value->IsNumber()) {
-            ReportLinkError("global import must be a number",
-                            index, module_name, import_name);
+            ReportLinkError("global import must be a number", index,
+                            module_name, import_name);
             return -1;
           }
           WriteGlobalValue(module_->globals[import.index], value);
           break;
         }
         default:
           UNREACHABLE();
           break;
       }
     }
@@ skipping 742 matching lines @@
 MaybeHandle<String> WasmCompiledModule::GetFunctionName(
     Handle<WasmCompiledModule> compiled_module, uint32_t func_index) {
   DCHECK_LT(func_index, compiled_module->module()->functions.size());
   WasmFunction& function = compiled_module->module()->functions[func_index];
   Isolate* isolate = compiled_module->GetIsolate();
   MaybeHandle<String> string = ExtractStringFromModuleBytes(
       isolate, compiled_module, function.name_offset, function.name_length);
   if (!string.is_null()) return string.ToHandleChecked();
   return {};
 }