[wasm] Generate source position information

src/compiler.h

 // Copyright 2012 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_H_
 #define V8_COMPILER_H_
 
 #include "src/allocation.h"
 #include "src/ast/ast.h"
 #include "src/bailout-reason.h"
 #include "src/compilation-dependencies.h"
 #include "src/source-position.h"
 #include "src/zone.h"
 
 namespace v8 {
 namespace internal {
 
 // Forward declarations.
 class CompilationInfo;
 class JavaScriptFrame;
 class OptimizedCompileJob;
 class ParseInfo;
 class ScriptData;
+namespace compiler {
+class SourcePositionTable;
+}
 
 // The V8 compiler API.
 //
 // This is the central hub for dispatching to the various compilers within V8.
 // Logic for which compiler to choose and how to wire compilation results into
 // the object heap should be kept inside this class.
 //
 // General strategy: Scripts are translated into anonymous functions w/o
 // parameters which then can be executed. If the source code contains other
 // functions, they might be compiled and allocated as part of the compilation
@@ skipping 416 matching lines @@
   }
 
   base::SmartArrayPointer<char> GetDebugName() const;
 
   Code::Kind output_code_kind() const {
     return Code::ExtractKindFromFlags(code_flags_);
   }
 
   StackFrame::Type GetOutputStackFrameType() const;
 
+  void SetSourcePositionTable(compiler::SourcePositionTable* table) {
+    source_position_table_ = table;

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

I'm not sure that the CompilationInfo is the best place to dump this, since it's
a compiler-internal field, but I don't have a better suggestion off the top of
my head.

[Michael Starzinger, 2016/04/18 11:08:47]

Not a fan of adding this to CompilationInfo either. IIUC, this is only needed to
pass the source position table from the WASM compiler into the TurboFan
pipeline. If we were to add a dedicated Pipeline::GenerateWASMCode, then we
could it pass in thorugh exactly that channel. This would also finally get rid
of the call to GenerateCodeForTesting from production code. WDYT?

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

Sounds reasonable. I will try to change it that way.

+  }
+
+  compiler::SourcePositionTable* GetSourcePositionTable() {
+    return source_position_table_;
+  }
+
  protected:
   ParseInfo* parse_info_;
 
   void DisableFutureOptimization() {
     if (GetFlag(kDisableFutureOptimization) && has_shared_info()) {
       // If Crankshaft tried to optimize this function, bailed out, and
       // doesn't want to try again, then use TurboFan next time.
       if (!shared_info()->dont_crankshaft() &&
           bailout_reason() != kOptimizedTooManyTimes) {
         shared_info()->set_dont_crankshaft(true);
@@ skipping 77 matching lines @@
 
   int optimization_id_;
 
   int osr_expr_stack_height_;
 
   // The current OSR frame for specialization or {nullptr}.
   JavaScriptFrame* osr_frame_ = nullptr;
 
   const char* debug_name_;
 
+  compiler::SourcePositionTable* source_position_table_ = nullptr;
+
   DISALLOW_COPY_AND_ASSIGN(CompilationInfo);
 };
 
 // A base class for compilation jobs intended to run concurrent to the main
 // thread. The job is split into three phases which are called in sequence on
 // different threads and with different limitations:
 //  1) CreateGraph:   Runs on main thread. No major limitations.
 //  2) OptimizeGraph: Runs concurrently. No heap allocation or handle derefs.
 //  3) GenerateCode:  Runs on main thread. No dependency changes.
 //
@@ skipping 49 matching lines @@
   MUST_USE_RESULT Status SetLastStatus(Status status) {
     last_status_ = status;
     return last_status_;
   }
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_H_