[wasm] remove faux code objects

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 <stdint.h>
 #include <stdlib.h>
 #include <string.h>
@@ skipping 60 matching lines @@
 
 const uint32_t kMaxGlobalsSize = 128;
 
 // A helper for module environments that adds the ability to allocate memory
 // and global variables. Contains a built-in {WasmModule} and
 // {WasmModuleInstance}.
 class TestingModule : public ModuleEnv {
  public:
   explicit TestingModule(WasmExecutionMode mode = kExecuteCompiled)
       : execution_mode_(mode),
+        linked_(false),
         instance_(&module_),
         isolate_(CcTest::InitIsolateOnce()),
         global_offset(0),
         interpreter_(mode == kExecuteInterpreted
                          ? new WasmInterpreter(&instance_, &allocator_)
                          : nullptr) {
     module = &module_;
     instance = &instance_;
     instance->module = &module_;
     instance->globals_start = global_data;
     module_.globals_size = kMaxGlobalsSize;
     instance->mem_start = nullptr;
     instance->mem_size = 0;
-    linker = nullptr;
     origin = kWasmOrigin;
     memset(global_data, 0, sizeof(global_data));
   }
 
   ~TestingModule() {
     if (instance->mem_start) {
       free(instance->mem_start);
     }
     if (interpreter_) delete interpreter_;
   }
@@ skipping 96 matching lines @@
     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<String> name = isolate_->factory()->NewStringFromStaticChars("main");
     Handle<JSObject> module_object = Handle<JSObject>(0, isolate_);
     Handle<Code> code = instance->function_code[index];
     WasmJs::InstallWasmFunctionMap(isolate_, isolate_->native_context());
-    return compiler::CompileJSToWasmWrapper(isolate_, this, name, code,
-                                            module_object, index);
+    Handle<JSFunction> ret = compiler::CompileJSToWasmWrapper(
+        isolate_, this, name, code, module_object, index);
+    Link();
+    return ret;
   }
 
   void SetFunctionCode(uint32_t index, Handle<Code> code) {
     instance->function_code[index] = code;
   }
 
   void AddIndirectFunctionTable(int* functions, int table_size) {
     Handle<FixedArray> fixed =
         isolate_->factory()->NewFixedArray(2 * table_size);
     instance->function_table = fixed;
@@ skipping 12 matching lines @@
       instance->function_table->set(i, Smi::FromInt(function->sig_index));
       instance->function_table->set(i + table_size,
                                     *instance->function_code[function_index]);
     }
   }
   WasmFunction* GetFunctionAt(int index) { return &module_.functions[index]; }
 
   WasmInterpreter* interpreter() { return interpreter_; }
   WasmExecutionMode execution_mode() { return execution_mode_; }
 
+  void Link() {
+    if (linked_) return;
+    compiler::Link(CcTest::i_isolate(), instance->function_code,
+                   instance->function_code, RelocInfo::kWasmDirectCallMask);
+    compiler::Link(CcTest::i_isolate(), instance->function_code,
+                   instance->import_code, RelocInfo::kWasmImportCallMask);
+
+    linked_ = true;
+  }
+
  private:
   WasmExecutionMode execution_mode_;
   WasmModule module_;
+  bool linked_;
   WasmModuleInstance instance_;
   Isolate* isolate_;
   v8::base::AccountingAllocator allocator_;
   uint32_t global_offset;
   V8_ALIGNED(8) byte global_data[kMaxGlobalsSize];  // preallocated global data.
   WasmInterpreter* interpreter_;
 
   const WasmGlobal* AddGlobal(MachineType mem_type) {
     byte size = WasmOpcodes::MemSize(mem_type);
     global_offset = (global_offset + size - 1) & ~(size - 1);  // align
@@ skipping 434 matching lines @@
       return Call(p0, p1, p2, 0);
     }
   }
 
   template <typename P0, typename P1, typename P2, typename P3>
   ReturnType Call(P0 p0, P1 p1, P2 p2, P3 p3) {
     if (interpret()) {
       WasmVal args[] = {WasmVal(p0), WasmVal(p1), WasmVal(p2), WasmVal(p3)};
       return CallInterpreter(ArrayVector(args));
     } else {
+      if (compiler_.testing_module_ != nullptr) {
+        compiler_.testing_module_->Link();
+      }
       CodeRunner<int32_t> runner(CcTest::InitIsolateOnce(),
                                  wrapper_.GetWrapperCode(),
                                  wrapper_.signature());
       ReturnType return_value;
       int32_t result = runner.Call<void*, void*, void*, void*, void*>(
           &p0, &p1, &p2, &p3, &return_value);
       CHECK_EQ(WASM_WRAPPER_RETURN_VALUE, result);
       return return_value;
     }
   }
@@ skipping 50 matching lines @@
 // interpreter.
 #define WASM_EXEC_TEST(name)                                               \
   void RunWasm_##name(WasmExecutionMode execution_mode);                   \
   TEST(RunWasmCompiled_##name) { RunWasm_##name(kExecuteCompiled); }       \
   TEST(RunWasmInterpreted_##name) { RunWasm_##name(kExecuteInterpreted); } \
   void RunWasm_##name(WasmExecutionMode execution_mode)
 
 }  // namespace
 
 #endif