[wasm] Always provide a wasm instance object at runtime

test/cctest/wasm/wasm-run-utils.h

 // Copyright 2016 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.
 
 #ifndef WASM_RUN_UTILS_H
 #define WASM_RUN_UTILS_H
 
 #include <setjmp.h>
 #include <stdint.h>
 #include <stdlib.h>
@@ skipping 73 matching lines @@
                                ModuleBytesEnv(&module_, &instance_,
                                               Vector<const byte>::empty()),
                                zone->allocator())
                          : nullptr) {
     instance->module = &module_;
     instance->globals_start = global_data;
     module_.globals_size = kMaxGlobalsSize;
     instance->mem_start = nullptr;
     instance->mem_size = 0;
     memset(global_data, 0, sizeof(global_data));
+    instance_object_ = InitInstanceObject();
   }
 
   ~TestingModule() {
     if (instance->mem_start) {
       free(instance->mem_start);
     }
     if (interpreter_) delete interpreter_;
   }
 
   void ChangeOriginToAsmjs() { module_.origin = kAsmJsOrigin; }
@@ skipping 69 matching lines @@
 
   // Pseudo-randomly intialize the memory.
   void RandomizeMemory(unsigned int seed = 88) {
     byte* raw = raw_mem_start<byte>();
     byte* end = raw_mem_end<byte>();
     v8::base::RandomNumberGenerator rng;
     rng.SetSeed(seed);
     rng.NextBytes(raw, end - raw);
   }
 
-  uint32_t AddFunction(FunctionSig* sig, Handle<Code> code) {
+  uint32_t AddFunction(FunctionSig* sig, Handle<Code> code, const char* name) {
     if (module->functions.size() == 0) {
       // TODO(titzer): Reserving space here to avoid the underlying WasmFunction
       // structs from moving.
       module_.functions.reserve(kMaxFunctions);
     }
     uint32_t index = static_cast<uint32_t>(module->functions.size());
     module_.functions.push_back({sig, index, 0, 0, 0, 0, 0, false, false});
+    if (name) {
+      Vector<const byte> name_vec = Vector<const byte>::cast(CStrVector(name));
+      module_.functions.back().name_offset = AddBytes(name_vec);
+      module_.functions.back().name_length = name_vec.length();
+    }
     instance->function_code.push_back(code);
     if (interpreter_) {
       const WasmFunction* function = &module->functions.back();
       int interpreter_index = interpreter_->AddFunctionForTesting(function);
       CHECK_EQ(index, static_cast<uint32_t>(interpreter_index));
     }
     DCHECK_LT(index, kMaxFunctions);  // limited for testing.
     return index;
   }
 
   uint32_t AddJsFunction(FunctionSig* sig, const char* source) {
     Handle<JSFunction> jsfunc = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
         *v8::Local<v8::Function>::Cast(CompileRun(source))));
-    uint32_t index = AddFunction(sig, Handle<Code>::null());
+    uint32_t index = AddFunction(sig, Handle<Code>::null(), nullptr);
     Handle<Code> code = CompileWasmToJSWrapper(
         isolate_, jsfunc, sig, index, Handle<String>::null(),
         Handle<String>::null(), module->origin);
     instance->function_code[index] = code;
     return index;
   }
 
   Handle<JSFunction> WrapCode(uint32_t index) {
     // Wrap the code so it can be called as a JS function.
     Handle<WasmInstanceObject> instance_obj(0, isolate_);
@@ skipping 43 matching lines @@
                    *instance->function_code[function.func_index]);
       }
     }
   }
 
   WasmFunction* GetFunctionAt(int index) { return &module_.functions[index]; }
 
   WasmInterpreter* interpreter() { return interpreter_; }
   WasmExecutionMode execution_mode() { return execution_mode_; }
   Isolate* isolate() { return isolate_; }
+  Handle<WasmInstanceObject> instance_object() { return instance_object_; }
 
  private:
   WasmExecutionMode execution_mode_;
   WasmModule module_;
   WasmInstance instance_;
   Isolate* isolate_;
   uint32_t global_offset;
   V8_ALIGNED(8) byte global_data[kMaxGlobalsSize];  // preallocated global data.
   WasmInterpreter* interpreter_;
+  Handle<WasmInstanceObject> instance_object_;
 
   const WasmGlobal* AddGlobal(LocalType type) {
     byte size = WasmOpcodes::MemSize(WasmOpcodes::MachineTypeFor(type));
     global_offset = (global_offset + size - 1) & ~(size - 1);  // align
     module_.globals.push_back(
         {type, true, WasmInitExpr(), global_offset, false, false});
     global_offset += size;
     // limit number of globals.
     CHECK_LT(global_offset, kMaxGlobalsSize);
     return &module->globals.back();
   }
+
+  uint32_t AddBytes(Vector<const byte> bytes) {
+    Handle<SeqOneByteString> old_bytes =
+        instance_object_->get_compiled_module()->module_bytes();
+    uint32_t old_size = static_cast<uint32_t>(old_bytes->length());
+    ScopedVector<byte> new_bytes(old_size + bytes.length());
+    memcpy(new_bytes.start(), old_bytes->GetChars(), old_size);
+    memcpy(new_bytes.start() + old_size, bytes.start(), bytes.length());
+    Handle<SeqOneByteString> new_bytes_str = Handle<SeqOneByteString>::cast(
+        isolate_->factory()->NewStringFromOneByte(new_bytes).ToHandleChecked());
+    instance_object_->get_compiled_module()->set_module_bytes(new_bytes_str);
+    return old_size;
+  }
+
+  Handle<WasmInstanceObject> InitInstanceObject() {
+    Handle<Managed<wasm::WasmModule>> module_wrapper =
+        Managed<wasm::WasmModule>::New(isolate_, &module_, false);
+    Handle<WasmCompiledModule> compiled_module =
+        WasmCompiledModule::New(isolate_, module_wrapper);
+    // Minimally initialize the compiled module such that IsWasmCompiledModule
+    // passes.
+    // If tests need more (correct) information, add it later.
+    compiled_module->set_min_mem_pages(0);
+    compiled_module->set_max_mem_pages(Smi::kMaxValue);
+    Handle<SeqOneByteString> empty_string = Handle<SeqOneByteString>::cast(
+        isolate_->factory()->NewStringFromOneByte({}).ToHandleChecked());
+    compiled_module->set_module_bytes(empty_string);
+    DCHECK(WasmCompiledModule::IsWasmCompiledModule(*compiled_module));
+    return WasmInstanceObject::New(isolate_, compiled_module);
+  }
 };
 
 inline void TestBuildingGraph(Zone* zone, JSGraph* jsgraph, ModuleEnv* module,
                               FunctionSig* sig,
                               SourcePositionTable* source_position_table,
                               const byte* start, const byte* end) {
   compiler::WasmGraphBuilder builder(zone, jsgraph, sig, source_position_table);
   DecodeResult result =
       BuildTFGraph(zone->allocator(), &builder, module, sig, start, end);
   if (result.failed()) {
@@ skipping 181 matching lines @@
     DCHECK_EQ(index, result);
     return result;
   }
 
   void SetSigIndex(int sig_index) { function_->sig_index = sig_index; }
 
  private:
   friend class WasmRunnerBase;
 
   explicit WasmFunctionCompiler(Zone* zone, FunctionSig* sig,
-                                TestingModule* module)
+                                TestingModule* module, const char* name)
       : GraphAndBuilders(zone),
         jsgraph(module->isolate(), this->graph(), this->common(), nullptr,
                 nullptr, this->machine()),
         sig(sig),
         descriptor_(nullptr),
         testing_module_(module),
         local_decls(zone, sig),
         source_position_table_(this->graph()),
         interpreter_(module->interpreter()) {
     // Get a new function from the testing module.
-    int index = module->AddFunction(sig, Handle<Code>::null());
+    int index = module->AddFunction(sig, Handle<Code>::null(), name);
     function_ = testing_module_->GetFunctionAt(index);
   }
 
   Handle<Code> Compile() {
     CallDescriptor* desc = descriptor();
     if (kPointerSize == 4) {
       desc = testing_module_->GetI32WasmCallDescriptor(this->zone(), desc);
     }
     CompilationInfo info(CStrVector("wasm"), this->isolate(), this->zone(),
                          Code::ComputeFlags(Code::WASM_FUNCTION));
     std::unique_ptr<CompilationJob> job(Pipeline::NewWasmCompilationJob(
         &info, &jsgraph, desc, &source_position_table_, nullptr));
     if (job->ExecuteJob() != CompilationJob::SUCCEEDED ||
         job->FinalizeJob() != CompilationJob::SUCCEEDED)
       return Handle<Code>::null();
 
     Handle<Code> code = info.code();
 
-    // Length is always 2, since usually <wasm_obj, func_index> is stored in
-    // the deopt data. Here, we only store the function index.
+    // Deopt data holds <WeakCell<wasm_instance>, func_index>.
     DCHECK(code->deoptimization_data() == nullptr ||
            code->deoptimization_data()->length() == 0);
     Handle<FixedArray> deopt_data =
         isolate()->factory()->NewFixedArray(2, TENURED);
+    Handle<Object> weak_instance =
+        isolate()->factory()->NewWeakCell(testing_module_->instance_object());
+    deopt_data->set(0, *weak_instance);
     deopt_data->set(1, Smi::FromInt(static_cast<int>(function_index())));
     deopt_data->set_length(2);
     code->set_deoptimization_data(*deopt_data);
 
 #ifdef ENABLE_DISASSEMBLER
     if (FLAG_print_opt_code) {
       OFStream os(stdout);
       code->Disassemble("wasm code", os);
     }
 #endif
@@ skipping 27 matching lines @@
   // more than once.
   void Build(const byte* start, const byte* end) {
     CHECK(!compiled_);
     compiled_ = true;
     functions_[0]->Build(start, end);
   }
 
   // Resets the state for building the next function.
   // The main function called will always be the first function.
   template <typename ReturnType, typename... ParamTypes>
-  WasmFunctionCompiler& NewFunction() {
-    return NewFunction(CreateSig<ReturnType, ParamTypes...>());
+  WasmFunctionCompiler& NewFunction(const char* name = nullptr) {
+    return NewFunction(CreateSig<ReturnType, ParamTypes...>(), name);
   }
 
   // Resets the state for building the next function.
   // The main function called will be the last generated function.
   // Returns the index of the previously built function.
-  WasmFunctionCompiler& NewFunction(FunctionSig* sig) {
-    functions_.emplace_back(new WasmFunctionCompiler(&zone_, sig, &module_));
+  WasmFunctionCompiler& NewFunction(FunctionSig* sig,
+                                    const char* name = nullptr) {
+    functions_.emplace_back(
+        new WasmFunctionCompiler(&zone_, sig, &module_, name));
     return *functions_.back();
   }
 
   byte AllocateLocal(LocalType type) {
     return functions_[0]->AllocateLocal(type);
   }
 
   WasmFunction* function() { return functions_[0]->function_; }
   WasmInterpreter* interpreter() { return functions_[0]->interpreter_; }
   bool possible_nondeterminism() { return possible_nondeterminism_; }
@@ skipping 53 matching lines @@
 
  public:
   // This field has to be static. Otherwise, gcc complains about the using in
   // the lambda context below.
   static jmp_buf jump_buffer;
 };
 
 template <typename ReturnType, typename... ParamTypes>
 class WasmRunner : public WasmRunnerBase {
  public:
-  explicit WasmRunner(WasmExecutionMode execution_mode)
+  explicit WasmRunner(WasmExecutionMode execution_mode,
+                      const char* main_fn_name = "main")
       : WasmRunnerBase(execution_mode, sizeof...(ParamTypes)) {
-    NewFunction<ReturnType, ParamTypes...>();
+    NewFunction<ReturnType, ParamTypes...>(main_fn_name);
     if (!interpret()) {
       wrapper_.Init<ReturnType, ParamTypes...>(functions_[0]->descriptor());
     }
   }
 
   ReturnType Call(ParamTypes... p) {
     DCHECK(compiled_);
     if (interpret()) return CallInterpreter(p...);
 
     // Use setjmp/longjmp to deal with traps in WebAssembly code.
@@ skipping 73 matching lines @@
   void RunWasm_##name(WasmExecutionMode execution_mode)
 
 #define WASM_EXEC_COMPILED_TEST(name)                                \
   void RunWasm_##name(WasmExecutionMode execution_mode);             \
   TEST(RunWasmCompiled_##name) { RunWasm_##name(kExecuteCompiled); } \
   void RunWasm_##name(WasmExecutionMode execution_mode)
 
 }  // namespace
 
 #endif