[wasm] Generate source position information

src/compiler/wasm-compiler.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 "src/compiler/wasm-compiler.h"
 
 #include "src/isolate-inl.h"
 
 #include "src/base/platform/elapsed-timer.h"
 #include "src/base/platform/platform.h"
@@ skipping 226 matching lines @@
       // End the control flow with returning 0xdeadbeef
       Node* ret_value = GetTrapValue(builder_->GetFunctionSignature());
       end = graph()->NewNode(jsgraph()->common()->Return(), ret_value,
                              *effect_ptr, *control_ptr);
     }
 
     MergeControlToEnd(jsgraph(), end);
   }
 };
 
-WasmGraphBuilder::WasmGraphBuilder(Zone* zone, JSGraph* jsgraph,
-                                   wasm::FunctionSig* function_signature)
+WasmGraphBuilder::WasmGraphBuilder(
+    Zone* zone, JSGraph* jsgraph, wasm::FunctionSig* function_signature,
+    compiler::SourcePositionTable* source_position_table)
     : zone_(zone),
       jsgraph_(jsgraph),
       module_(nullptr),
       mem_buffer_(nullptr),
       mem_size_(nullptr),
       function_table_(nullptr),
       control_(nullptr),
       effect_(nullptr),
       cur_buffer_(def_buffer_),
       cur_bufsize_(kDefaultBufferSize),
       trap_(new (zone) WasmTrapHelper(this)),
-      function_signature_(function_signature) {
+      function_signature_(function_signature),
+      source_position_table_(source_position_table) {
   DCHECK_NOT_NULL(jsgraph_);
+  DCHECK_IMPLIES(source_position_table != nullptr,
+                 source_position_table->GetGraph() == graph());
 }
 
 
 Node* WasmGraphBuilder::Error() { return jsgraph()->Dead(); }
 
 
 Node* WasmGraphBuilder::Start(unsigned params) {
   Node* start = graph()->NewNode(jsgraph()->common()->Start(params));
   graph()->SetStart(start);
   return start;
@@ skipping 2391 matching lines @@
 
 void WasmGraphBuilder::Int64LoweringForTesting() {
   if (jsgraph()->machine()->Is32()) {
     Int64Lowering r(jsgraph()->graph(), jsgraph()->machine(),
                     jsgraph()->common(), jsgraph()->zone(),
                     function_signature_);
     r.LowerGraph();
   }
 }
 
+void WasmGraphBuilder::SetSourcePosition(Node* node, int position) {
+  compiler::SourcePosition pos(position);
+  if (source_position_table_)
+    source_position_table_->SetSourcePosition(node, pos);
+}
+
 static void RecordFunctionCompilation(Logger::LogEventsAndTags tag,
                                       CompilationInfo* info,
                                       const char* message, uint32_t index,
                                       wasm::WasmName func_name) {
   Isolate* isolate = info->isolate();
   if (isolate->logger()->is_logging_code_events() ||
       isolate->cpu_profiler()->is_profiling()) {
     ScopedVector<char> buffer(128);
     SNPrintF(buffer, "%s#%d:%.*s", message, index, func_name.length,
              func_name.name);
@@ skipping 72 matching lines @@
     static unsigned id = 0;
     Vector<char> buffer;
     if (debugging) {
       buffer = Vector<char>::New(128);
       SNPrintF(buffer, "js-to-wasm#%d", id);
       func_name = buffer.start();
     }
 
     CompilationInfo info(func_name, isolate, &zone, flags);
     Handle<Code> code =
-        Pipeline::GenerateCodeForTesting(&info, incoming, &graph, nullptr);
+        Pipeline::GenerateCodeForTesting(&info, incoming, &graph);
 #ifdef ENABLE_DISASSEMBLER
     if (FLAG_print_opt_code && !code.is_null()) {
       OFStream os(stdout);
       code->Disassemble(buffer.start(), os);
     }
 #endif
     if (debugging) {
       buffer.Dispose();
     }
 
@@ skipping 98 matching lines @@
   }
 
   // Create a TF graph during decoding.
   Zone zone(isolate->allocator());
   Graph graph(&zone);
   CommonOperatorBuilder common(&zone);
   MachineOperatorBuilder machine(
       &zone, MachineType::PointerRepresentation(),
       InstructionSelector::SupportedMachineOperatorFlags());
   JSGraph jsgraph(isolate, &graph, &common, nullptr, nullptr, &machine);
-  WasmGraphBuilder builder(&zone, &jsgraph, function.sig);
+  SourcePositionTable source_position_table(&graph);
+  WasmGraphBuilder builder(&zone, &jsgraph, function.sig,
+                           &source_position_table);
   wasm::FunctionBody body = {
       module_env, function.sig, module_env->module->module_start,
       module_env->module->module_start + function.code_start_offset,
       module_env->module->module_start + function.code_end_offset};
+
   wasm::TreeResult result =
       wasm::BuildTFGraph(isolate->allocator(), &builder, body);
 
   if (machine.Is32()) {
     Int64Lowering r(&graph, &machine, &common, &zone, function.sig);
     r.LowerGraph();
   }
 
   if (result.failed()) {
     if (FLAG_trace_wasm_compiler) {
@@ skipping 22 matching lines @@
   base::ElapsedTimer compile_timer;
   if (FLAG_trace_wasm_decode_time) {
     compile_timer.Start();
   }
   // Run the compiler pipeline to generate machine code.
   CallDescriptor* descriptor =
       wasm::ModuleEnv::GetWasmCallDescriptor(&zone, function.sig);
   if (machine.Is32()) {
     descriptor = module_env->GetI32WasmCallDescriptor(&zone, descriptor);
   }
+
   Code::Flags flags = Code::ComputeFlags(Code::WASM_FUNCTION);
   // add flags here if a meaningful name is helpful for debugging.
   bool debugging =
 #if DEBUG
       true;
 #else
       FLAG_print_opt_code || FLAG_trace_turbo || FLAG_trace_turbo_graph;
 #endif
   const char* func_name = "wasm";
   Vector<char> buffer;
   if (debugging) {
     buffer = Vector<char>::New(128);
     wasm::WasmName name =
         module_env->module->GetName(function.name_offset, function.name_length);
     SNPrintF(buffer, "WASM_function_#%d:%.*s", function.func_index, name.length,
              name.name);
     func_name = buffer.start();
   }
   CompilationInfo info(func_name, isolate, &zone, flags);
 
-  Handle<Code> code =
-      Pipeline::GenerateCodeForTesting(&info, descriptor, &graph);
+  Handle<Code> code = Pipeline::GenerateWASMCode(&info, descriptor, &graph,
+                                                 &source_position_table);
   if (debugging) {
     buffer.Dispose();
   }
   if (!code.is_null()) {
     RecordFunctionCompilation(Logger::FUNCTION_TAG, &info, "WASM_function",
                               function.func_index,
                               module_env->module->GetName(
                                   function.name_offset, function.name_length));
   }
 
   if (FLAG_trace_wasm_decode_time) {
     double compile_ms = compile_timer.Elapsed().InMillisecondsF();
     PrintF(
         "wasm-compile ok: %d bytes, %0.3f ms decode, %d nodes, %0.3f ms "
         "compile\n",
         static_cast<int>(function.code_end_offset - function.code_start_offset),
         decode_ms, static_cast<int>(graph.NodeCount()), compile_ms);
   }
   // TODO(bradnelson): Improve histogram handling of size_t.
   isolate->counters()->wasm_compile_function_peak_memory_bytes()->AddSample(
       static_cast<int>(zone.allocation_size()));
   return code;
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8