[wasm] Generate source position information

src/compiler/wasm-compiler.h

 // 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.
 
 #ifndef V8_COMPILER_WASM_COMPILER_H_
 #define V8_COMPILER_WASM_COMPILER_H_
 
 // Clients of this interface shouldn't depend on lots of compiler internals.
 // Do not include anything from src/compiler here!
 #include "src/wasm/wasm-opcodes.h"
 #include "src/zone.h"
 
 namespace v8 {
 namespace internal {
 
 namespace compiler {
 // Forward declarations for some compiler data structures.
 class Node;
 class JSGraph;
 class Graph;
+class SourcePositionTable;
+class SourcePositionScope;
 }
 
 namespace wasm {
 // Forward declarations for some WASM data structures.
 struct ModuleEnv;
 struct WasmFunction;
 class ErrorThrower;
 
 // Expose {Node} and {Graph} opaquely as {wasm::TFNode} and {wasm::TFGraph}.
 typedef compiler::Node TFNode;
@@ skipping 17 matching lines @@
 // from JavaScript.
 Handle<JSFunction> CompileJSToWasmWrapper(
     Isolate* isolate, wasm::ModuleEnv* module, Handle<String> name,
     Handle<Code> wasm_code, Handle<JSObject> module_object, uint32_t index);
 
 // Abstracts details of building TurboFan graph nodes for WASM to separate
 // the WASM decoder from the internal details of TurboFan.
 class WasmTrapHelper;
 class WasmGraphBuilder {
  public:
-  WasmGraphBuilder(Zone* z, JSGraph* g, wasm::FunctionSig* function_signature);
+  WasmGraphBuilder(
+      Zone* z, JSGraph* g, wasm::FunctionSig* function_signature,
+      compiler::SourcePositionTable* source_position_table = nullptr);
+
+  ~WasmGraphBuilder() {
+    // check that Enter- / LeaveSourcePositionScope is balanced
+    DCHECK_NULL(source_position_scope_);
+  }
 
   Node** Buffer(size_t count) {
     if (count > cur_bufsize_) {
       size_t new_size = count + cur_bufsize_ + 5;
       cur_buffer_ =
           reinterpret_cast<Node**>(zone_->New(new_size * sizeof(Node*)));
       cur_bufsize_ = new_size;
     }
     return cur_buffer_;
   }
@@ skipping 65 matching lines @@
   void set_module(wasm::ModuleEnv* module) { this->module_ = module; }
 
   void set_control_ptr(Node** control) { this->control_ = control; }
 
   void set_effect_ptr(Node** effect) { this->effect_ = effect; }
 
   wasm::FunctionSig* GetFunctionSignature() { return function_signature_; }
 
   void Int64LoweringForTesting();
 
+  // Register a graph decorator to assign source positions to nodes (in

[titzer, 2016/04/18 11:03:51]

I don't think we should add scoping for this. I think it'd be better to pass the
source position explicitly to the methods that build nodes, for exactly those
nodes that need positions. Those are binops (because division can trap) and
calls.

[Clemens Hammacher, 2016/04/18 11:18:10]

What about step-through debugging? Wouldn't that require source position
information on basically each single node?

+  // source_position_table_). Only has an effect if source_position_table_ is
+  // non-null. Ensure to call LeaveSourcePositionScope afterwards.
+  void EnterSourcePositionScope();
+  void LeaveSourcePositionScope();
+
+  // Set current source position, such that all nodes created after this call
+  // get the respecitve position assigned. This only has an effect if
+  // source_position_table_ is non-null and EnterSourcePositionScope was called
+  // before.
+  void SetCurrentSourcePosition(int position);
+
  private:
   static const int kDefaultBufferSize = 16;
   friend class WasmTrapHelper;
 
   Zone* zone_;
   JSGraph* jsgraph_;
   wasm::ModuleEnv* module_;
   Node* mem_buffer_;
   Node* mem_size_;
   Node* function_table_;
   Node** control_;
   Node** effect_;
   Node** cur_buffer_;
   size_t cur_bufsize_;
   Node* def_buffer_[kDefaultBufferSize];
 
   WasmTrapHelper* trap_;
   wasm::FunctionSig* function_signature_;
 
+  compiler::SourcePositionTable* source_position_table_ = nullptr;
+  compiler::SourcePositionScope* source_position_scope_ = nullptr;
+
   // Internal helper methods.
   JSGraph* jsgraph() { return jsgraph_; }
   Graph* graph();
 
   Node* String(const char* string);
   Node* MemBuffer(uint32_t offset);
   void BoundsCheckMem(MachineType memtype, Node* index, uint32_t offset);
 
   Node* MaskShiftCount32(Node* node);
   Node* MaskShiftCount64(Node* node);
@@ skipping 76 matching lines @@
     Node** buf = Buffer(new_count);
     if (buf != buffer) memcpy(buf, buffer, old_count * sizeof(Node*));
     return buf;
   }
 };
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_WASM_COMPILER_H_