[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 227 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_);
 }
 
 
 Node* WasmGraphBuilder::Error() { return jsgraph()->Dead(); }
 
 
 Node* WasmGraphBuilder::Start(unsigned params) {
   Node* start = graph()->NewNode(jsgraph()->common()->Start(params));
   graph()->SetStart(start);
@@ skipping 2385 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 70 matching lines @@
     if (debugging) {
       buffer.Dispose();
     }
 
     RecordFunctionCompilation(Logger::FUNCTION_TAG, &info, "wasm-to-js", 0,
                               module_name);
   }
   return code;
 }
 
-JSGraph* BuildGraphForWasmFunction(Zone* zone, wasm::ErrorThrower& thrower,
-                                   Isolate* isolate,
-                                   wasm::ModuleEnv*& module_env,
-                                   const wasm::WasmFunction& function,
-                                   double* decode_ms) {
+std::pair<JSGraph*, SourcePositionTable*> BuildGraphForWasmFunction(
+    Zone* zone, wasm::ErrorThrower& thrower, Isolate* isolate,
+    wasm::ModuleEnv*& module_env, const wasm::WasmFunction& function,
+    double* decode_ms) {
   base::ElapsedTimer decode_timer;
   if (FLAG_trace_wasm_decode_time) {
     decode_timer.Start();
   }
   // Create a TF graph during decoding.
   Graph* graph = new (zone) Graph(zone);
   CommonOperatorBuilder* common = new (zone) CommonOperatorBuilder(zone);
   MachineOperatorBuilder* machine = new (zone) MachineOperatorBuilder(
       zone, MachineType::PointerRepresentation(),
       InstructionSelector::SupportedMachineOperatorFlags());
   JSGraph* jsgraph =
       new (zone) JSGraph(isolate, graph, common, nullptr, nullptr, machine);
-  WasmGraphBuilder builder(zone, jsgraph, function.sig);
+  SourcePositionTable* source_position_table =
+      new (zone) SourcePositionTable(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) {
       OFStream os(stdout);
       os << "Compilation failed: " << result << std::endl;
     }
     // Add the function as another context for the exception
     ScopedVector<char> buffer(128);
     wasm::WasmName name =
         module_env->module->GetName(function.name_offset, function.name_length);
     SNPrintF(buffer, "Compiling WASM function #%d:%.*s failed:",
              function.func_index, name.length, name.name);
     thrower.Failed(buffer.start(), result);
-    return nullptr;
+    return std::make_pair(nullptr, nullptr);
   }
   int index = static_cast<int>(function.func_index);
   if (index >= FLAG_trace_wasm_ast_start && index < FLAG_trace_wasm_ast_end) {
     PrintAst(isolate->allocator(), body);
   }
   if (FLAG_trace_wasm_decode_time) {
     *decode_ms = decode_timer.Elapsed().InMillisecondsF();
   }
-  return jsgraph;
+  return std::make_pair(jsgraph, source_position_table);
 }
 
 // Helper function to compile a single function.
 Handle<Code> CompileWasmFunction(wasm::ErrorThrower& thrower, Isolate* isolate,
                                  wasm::ModuleEnv* module_env,
                                  const wasm::WasmFunction& function) {
   HistogramTimerScope wasm_compile_function_time_scope(
       isolate->counters()->wasm_compile_function_time());
   if (FLAG_trace_wasm_compiler) {
     OFStream os(stdout);
     os << "Compiling WASM function "
        << wasm::WasmFunctionName(&function, module_env) << std::endl;
     os << std::endl;
   }
 
   compiler::ZonePool zone_pool(isolate->allocator());
   compiler::ZonePool::Scope graph_zone_scope(&zone_pool);
   double decode_ms = 0;
-  JSGraph* jsgraph =
+  std::pair<JSGraph*, SourcePositionTable*> graph_result =
       BuildGraphForWasmFunction(graph_zone_scope.zone(), thrower, isolate,
                                 module_env, function, &decode_ms);
+  JSGraph* jsgraph = graph_result.first;
+  SourcePositionTable* source_positions = graph_result.second;
 
   if (jsgraph == nullptr) {
     return Handle<Code>::null();
   }
 
   base::ElapsedTimer compile_timer;
   if (FLAG_trace_wasm_decode_time) {
     compile_timer.Start();
   }
   // Run the compiler pipeline to generate machine code.
@@ skipping 18 matching lines @@
     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, jsgraph->graph()->zone(), flags);
   compiler::ZonePool::Scope pipeline_zone_scope(&zone_pool);
   Pipeline pipeline(&info);
   pipeline.InitializeWasmCompilation(pipeline_zone_scope.zone(), &zone_pool,
-                                     jsgraph->graph());
+                                     jsgraph->graph(), source_positions);
   Handle<Code> code;
   if (pipeline.ExecuteWasmCompilation(descriptor)) {
     code = pipeline.FinalizeWasmCompilation(descriptor);
   } else {
     code = Handle<Code>::null();
   }
 
   if (debugging) {
     buffer.Dispose();
   }
@@ skipping 16 matching lines @@
   isolate->counters()->wasm_compile_function_peak_memory_bytes()->AddSample(
       static_cast<int>(jsgraph->graph()->zone()->allocation_size()));
   graph_zone_scope.Destroy();
   return code;
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8