[wasm] Generate source position information

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-module.h"
 #include "src/wasm/wasm-opcodes.h"
 
 #include "src/zone.h"
 
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/call-tester.h"
@@ skipping 205 matching lines @@
     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();
   }
 };
 
 inline void TestBuildingGraph(Zone* zone, JSGraph* jsgraph, ModuleEnv* module,
-                              FunctionSig* sig, const byte* start,
-                              const byte* end) {
-  compiler::WasmGraphBuilder builder(zone, jsgraph, sig);
+                              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()) {
     ptrdiff_t pc = result.error_pc - result.start;
     ptrdiff_t pt = result.error_pt - result.start;
     std::ostringstream str;
     str << "Verification failed: " << result.error_code << " pc = +" << pc;
     if (result.error_pt) str << ", pt = +" << pt;
     str << ", msg = " << result.error_msg.get();
     FATAL(str.str().c_str());
@@ skipping 153 matching lines @@
                              private GraphAndBuilders {
  public:
   explicit WasmFunctionCompiler(FunctionSig* sig, TestingModule* module,
                                 const char* debug_name = "<WASM UNNAMED>")
       : GraphAndBuilders(main_zone()),
         jsgraph(this->isolate(), this->graph(), this->common(), nullptr,
                 nullptr, this->machine()),
         sig(sig),
         descriptor_(nullptr),
         testing_module_(module),
-        debug_name_(debug_name) {
+        debug_name_(debug_name),
+        source_position_table_(this->graph()) {
     if (module) {
       // Get a new function from the testing module.
       function_ = nullptr;
       function_index_ = module->AddFunction(sig, Handle<Code>::null());
     } else {
       // Create our own function.
       function_ = new WasmFunction();
       function_->sig = sig;
       function_index_ = 0;
     }
   }
 
   ~WasmFunctionCompiler() {
     if (function_) delete function_;
   }
 
   JSGraph jsgraph;
   FunctionSig* sig;
   // The call descriptor is initialized when the function is compiled.
   CallDescriptor* descriptor_;
   TestingModule* testing_module_;
   const char* debug_name_;
   WasmFunction* function_;
   int function_index_;
   LocalDeclEncoder local_decls;
+  SourcePositionTable source_position_table_;
 
   Isolate* isolate() { return main_isolate(); }
   Graph* graph() const { return main_graph_; }
   Zone* zone() const { return graph()->zone(); }
   CommonOperatorBuilder* common() { return &main_common_; }
   MachineOperatorBuilder* machine() { return &main_machine_; }
   void InitializeDescriptor() {
     if (descriptor_ == nullptr) {
       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, start, end);
+    TestBuildingGraph(main_zone(), &jsgraph, testing_module_, sig,
+                      &source_position_table_, 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;
   }
 
   Handle<Code> Compile() {
     InitializeDescriptor();
     CallDescriptor* desc = descriptor_;
     if (kPointerSize == 4) {
       desc = testing_module_->GetI32WasmCallDescriptor(this->zone(), desc);
     }
     CompilationInfo info(debug_name_, this->isolate(), this->zone(),
                          Code::ComputeFlags(Code::WASM_FUNCTION));
-    Handle<Code> result =
-        Pipeline::GenerateCodeForTesting(&info, desc, this->graph());
+    compiler::ZonePool zone_pool(this->isolate()->allocator());
+    compiler::ZonePool::Scope pipeline_zone_scope(&zone_pool);
+    Pipeline pipeline(&info);
+    pipeline.InitializeWasmCompilation(this->zone(), &zone_pool, this->graph(),
+                                       &source_position_table_);
+    Handle<Code> code;
+    if (pipeline.ExecuteWasmCompilation(desc)) {
+      code = pipeline.FinalizeWasmCompilation(desc);
+    } else {
+      code = Handle<Code>::null();
+    }
+    pipeline_zone_scope.Destroy();
 #ifdef ENABLE_DISASSEMBLER
-    if (!result.is_null() && FLAG_print_opt_code) {
+    if (!code.is_null() && FLAG_print_opt_code) {
       OFStream os(stdout);
-      result->Disassemble("wasm code", os);
+      code->Disassemble("wasm code", os);
     }
 #endif
 
-    return result;
+    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);
     return static_cast<uint32_t>(function_index_);
   }
 
@@ skipping 129 matching lines @@
     if (p1 == MachineType::None()) return 1;
     if (p2 == MachineType::None()) return 2;
     if (p3 == MachineType::None()) return 3;
     return 4;
   }
 };
 
 }  // namespace
 
 #endif