[wasm] Add tests for function name encoding

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>
 
 #include "src/base/utils/random-number-generator.h"
 
 #include "src/compiler/graph-visualizer.h"
 #include "src/compiler/int64-lowering.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/node.h"
 #include "src/compiler/pipeline.h"
 #include "src/compiler/wasm-compiler.h"
 #include "src/compiler/zone-pool.h"
 
 #include "src/wasm/ast-decoder.h"
 #include "src/wasm/wasm-js.h"
+#include "src/wasm/wasm-macro-gen.h"
 #include "src/wasm/wasm-module.h"
 #include "src/wasm/wasm-opcodes.h"
 
 #include "src/zone.h"
 
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/call-tester.h"
 #include "test/cctest/compiler/graph-builder-tester.h"
 
 // TODO(titzer): pull WASM_64 up to a common header.
@@ skipping 161 matching lines @@
     Handle<Code> code = instance->function_code[index];
     WasmJs::InstallWasmFunctionMap(isolate, isolate->native_context());
     return compiler::CompileJSToWasmWrapper(isolate, this, name, code,
                                             module_object, index);
   }
 
   void SetFunctionCode(uint32_t index, Handle<Code> code) {
     instance->function_code[index] = code;
   }
 
+  void SetFunctionBytes(uint32_t index, const byte* start, const byte* end) {
+    int length = static_cast<int>(end - start);
+    DCHECK_EQ(end - start, length);
+    uint32_t bytes_offset = AddModuleBytes(Vector<const byte>(start, length));
+    module_.functions[index].code_start_offset = bytes_offset;
+    module_.functions[index].code_end_offset = bytes_offset + length;
+  }
+
+  void SetFunctionName(uint32_t index, Vector<const char> name) {
+    uint32_t name_offset = AddModuleBytes(Vector<const byte>(
+        reinterpret_cast<const byte*>(name.start()), name.length()));
+    module_.functions[index].name_offset = name_offset;
+    module_.functions[index].name_length = name.length();
+  }
+
   void AddIndirectFunctionTable(int* functions, int table_size) {
     Isolate* isolate = module->shared_isolate;
     Handle<FixedArray> fixed =
         isolate->factory()->NewFixedArray(2 * table_size);
     instance->function_table = fixed;
     DCHECK_EQ(0u, module->function_table.size());
     for (int i = 0; i < table_size; i++) {
       module->function_table.push_back(functions[i]);
     }
   }
 
   void PopulateIndirectFunctionTable() {
     if (instance->function_table.is_null()) return;
     int table_size = static_cast<int>(module->function_table.size());
     for (int i = 0; i < table_size; i++) {
       int function_index = module->function_table[i];
       WasmFunction* function = &module->functions[function_index];
       instance->function_table->set(i, Smi::FromInt(function->sig_index));
       instance->function_table->set(i + table_size,
                                     *instance->function_code[function_index]);
     }
   }
 
+  Handle<JSObject> Instantiate() {
+    Isolate* isolate = module->shared_isolate;
+    Handle<JSObject> ffi;          // We don't need ffi in tests.
+    Handle<JSArrayBuffer> memory;  // We don't need memory in tests.
+    return module->Instantiate(isolate, ffi, memory).ToHandleChecked();
+  }
+
  private:
   WasmModule module_;
   WasmModuleInstance instance_;
   uint32_t global_offset;
   V8_ALIGNED(8) byte global_data[kMaxGlobalsSize];  // preallocated global data.
 
+  // This vector contains function names and wasm code, but not in any valid
+  // format. It is references by WasmFunctions (name_offset, code_start_offset).
+  std::vector<byte> module_bytes_;
+
   WasmGlobal* AddGlobal(MachineType mem_type) {
     byte size = WasmOpcodes::MemSize(mem_type);
     global_offset = (global_offset + size - 1) & ~(size - 1);  // align
     module->globals.push_back({0, 0, mem_type, global_offset, false});
     global_offset += size;
     // limit number of globals.
     CHECK_LT(global_offset, kMaxGlobalsSize);
     return &module->globals.back();
   }
+
+  uint32_t AddModuleBytes(Vector<const byte> bytes) {
+    DCHECK(module->module_start == nullptr ||
+           module->module_start == module_bytes_.data());
+    DCHECK_EQ(module->module_start == nullptr, module_bytes_.empty());
+    module_bytes_.insert(module_bytes_.end(), bytes.start(),
+                         bytes.start() + bytes.length());
+    module->module_start = module_bytes_.data();
+    module->module_end = module_bytes_.data() + module_bytes_.size();
+    return static_cast<uint32_t>(module_bytes_.size() - bytes.length());
+  }
 };
 
 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);
   TreeResult result =
       BuildTFGraph(zone->allocator(), &builder, module, sig, start, end);
   if (result.failed()) {
@@ skipping 207 matching lines @@
       descriptor_ = testing_module_->GetWasmCallDescriptor(main_zone(), sig);
     }
   }
   CallDescriptor* descriptor() { return descriptor_; }
 
   void Build(const byte* start, const byte* end) {
     // Build the TurboFan graph.
     local_decls.Prepend(&start, &end);
     TestBuildingGraph(main_zone(), &jsgraph, testing_module_, sig,
                       &source_position_table_, start, end);
+    if (testing_module_ != nullptr)
+      testing_module_->SetFunctionBytes(function_index_, start, end);
     delete[] start;
   }
 
   byte AllocateLocal(LocalType type) {
     uint32_t index = local_decls.AddLocals(1, type, sig);
     byte result = static_cast<byte>(index);
     DCHECK_EQ(index, result);
     return result;
   }
 
@@ skipping 36 matching lines @@
 #endif
 
     return code;
   }
 
   uint32_t CompileAndAdd(uint16_t sig_index = 0) {
     CHECK(testing_module_);
     function()->sig_index = sig_index;
     Handle<Code> code = Compile();
     testing_module_->SetFunctionCode(function_index_, code);
+    if (debug_name_.start() != nullptr)
+      testing_module_->SetFunctionName(function_index_, debug_name_);
     return static_cast<uint32_t>(function_index_);
   }
 
   WasmFunction* function() {
     if (function_) return function_;
     return &testing_module_->module->functions[function_index_];
   }
 
   // Set the context, such that e.g. runtime functions can be called.
   void SetModuleContext() {
@@ skipping 122 matching lines @@
     if (p1 == MachineType::None()) return 1;
     if (p2 == MachineType::None()) return 2;
     if (p3 == MachineType::None()) return 3;
     return 4;
   }
 };
 
 }  // namespace
 
 #endif