[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 230 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 2196 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::EnterSourcePositionScope() {
+  DCHECK_NULL(source_position_scope_);
+  if (source_position_table_) {
+    source_position_table_->AddDecorator();
+    source_position_scope_ = new SourcePositionScope(source_position_table_);
+  }
+}
+
+void WasmGraphBuilder::LeaveSourcePositionScope() {
+  DCHECK_EQ(!!source_position_table_, !!source_position_scope_);
+  if (!source_position_scope_) return;
+  delete source_position_scope_;
+  source_position_scope_ = nullptr;
+  source_position_table_->RemoveDecorator();
+}
+
+void WasmGraphBuilder::SetCurrentSourcePosition(int position) {
+  if (source_position_scope_)
+    source_position_scope_->SetCurrentPosition(SourcePosition(position));
+}
+
 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 212 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};
+
+  builder.EnterSourcePositionScope();
   wasm::TreeResult result =
       wasm::BuildTFGraph(isolate->allocator(), &builder, body);
+  builder.LeaveSourcePositionScope();
 
   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);
@@ skipping 15 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);
+  // TODO(clemensh): make source position tracking optional
+  info.MarkAsSourcePositionsEnabled();
+  info.SetSourcePositionTable(&source_position_table);
 
   Handle<Code> code =
       Pipeline::GenerateCodeForTesting(&info, descriptor, &graph);
   if (debugging) {
     buffer.Dispose();
   }
   if (!code.is_null()) {
     RecordFunctionCompilation(Logger::FUNCTION_TAG, &info, "WASM_function",
                               function.func_index,
                               module_env->module->GetName(
@@ skipping 11 matching lines @@
   // 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