Uniform and precise source positions for inlining

src/source-position.cc

Index: src/source-position.cc
diff --git a/src/source-position.cc b/src/source-position.cc
new file mode 100644
index 0000000000000000000000000000000000000000..3622210d80122b9027c998e3c407723dd4a9133b
--- /dev/null
+++ b/src/source-position.cc
@@ -0,0 +1,124 @@
+// Copyright 2016 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/source-position.h"
+#include "src/compilation-info.h"
+#include "src/objects-inl.h"
+
+namespace v8 {
+namespace internal {
+
+std::ostream& operator<<(std::ostream& out, const SourcePositionInfo& pos) {
+  Handle<SharedFunctionInfo> function;
+  if (pos.function.ToHandle(&function)) {
+    Handle<Script> script(Script::cast(function->script()));
+    Handle<String> name(String::cast(script->name()));
+    out << "<" << name->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL).get()
+        << ":" << pos.line + 1 << ":" << pos.column + 1 << ">";
+  } else {
+    out << "<unknown:" << pos.position.ScriptOffset() << ">";
+  }
+  return out;
+}
+
+std::ostream& operator<<(std::ostream& out,
+                         const std::vector<SourcePositionInfo>& stack) {
+  bool first = true;
+  out << stack.back();
+  for (int i = static_cast<int>(stack.size()) - 2; i >= 0; --i) {
+    out << " inlined at ";
+    out << stack[i];
+  }
+  return out;
+}
+
+std::ostream& operator<<(std::ostream& out, const SourcePosition& pos) {
+  out << "<" << pos.InliningId() << ":" << pos.ScriptOffset() << ">";
+  return out;
+}
+
+SourcePositionInfo SourcePosition::Info(
+    Handle<SharedFunctionInfo> function) const {
+  Handle<Script> script(Script::cast(function->script()));
+  SourcePositionInfo result(*this);
+  Script::PositionInfo pos;
+  if (script->GetPositionInfo(ScriptOffset(), &pos, Script::NO_OFFSET)) {
+    result.line = pos.line;
+    result.column = pos.column;
+  }
+  result.function = function;
+  return result;
+}
+
+std::vector<SourcePositionInfo> SourcePosition::Info(
+    CompilationInfo* cinfo) const {
+  if (InliningId() == kNotInlined) {
+    return std::vector<SourcePositionInfo>{Info(cinfo->shared_info())};
+  } else {
+    InliningPosition inl = cinfo->inlined_functions()[InliningId()].position;
+    std::vector<SourcePositionInfo> stack = inl.position.Info(cinfo);
+    stack.push_back(Info(cinfo->inlined_functions()[InliningId()].shared_info));
+    return stack;
+  }
+}
+
+std::vector<SourcePositionInfo> SourcePosition::Info(Handle<Code> code) const {

[vogelheim, 2016/11/04 10:57:41]

I don't get this. If I read the code below correctly, every code path will
return a vector with a single element in it. Why use a vector, rather than just
returning a SourcePositionInfo?

(Same applies to function above.)

[Yang, 2016/11/04 14:32:59]

I guess the vector is supposed to return the full inlining stack. This method
should be named accordingly.

+  Handle<DeoptimizationInputData> deopt_data(
+      DeoptimizationInputData::cast(code->deoptimization_data()));
+  if (InliningId() == kNotInlined) {
+    Handle<SharedFunctionInfo> function(
+        SharedFunctionInfo::cast(deopt_data->SharedFunctionInfo()));
+
+    return std::vector<SourcePositionInfo>{Info(function)};
+  } else {
+    InliningPosition inl = deopt_data->InliningPositions()->get(InliningId());
+    std::vector<SourcePositionInfo> stack = inl.position.Info(code);
+    if (inl.inlined_function_id == -1) {
+      stack.push_back(SourcePositionInfo(*this));

[vogelheim, 2016/11/04 10:57:41]

nipitck: (here & function above)

You sometimes build the return value with 
  return std::vector<...>{ value }
and sometimes with
  std::vector<..> result;
  result.push_back( value );
  return result;

Is there any reason for this?

+    } else {
+      Handle<SharedFunctionInfo> function(SharedFunctionInfo::cast(
+          deopt_data->LiteralArray()->get(inl.inlined_function_id)));
+      stack.push_back(Info(function));
+    }
+    return stack;
+  }
+}
+
+void SourcePosition::Print(std::ostream& out) const {
+  out << "<" << ScriptOffset() << ">";

[vogelheim, 2016/11/04 10:57:41]

Why not print the inline id?
Also, should there be a representation for the 'magic' values?

+}
+
+void SourcePosition::Print(std::ostream& out,
+                           SharedFunctionInfo* function) const {
+  Script* script = Script::cast(function->script());
+  String* name = String::cast(script->name());
+  Script::PositionInfo pos;
+  script->GetPositionInfo(ScriptOffset(), &pos, Script::NO_OFFSET);
+  out << "<" << name->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL).get()
+      << ":" << pos.line + 1 << ":" << pos.column + 1 << ">";
+}
+
+void SourcePosition::Print(std::ostream& out, Code* code) const {
+  DeoptimizationInputData* deopt_data =
+      DeoptimizationInputData::cast(code->deoptimization_data());
+  if (InliningId() == kNotInlined) {
+    SharedFunctionInfo* function(
+        SharedFunctionInfo::cast(deopt_data->SharedFunctionInfo()));
+    Print(out, function);
+  } else {
+    InliningPosition inl = deopt_data->InliningPositions()->get(InliningId());
+    if (inl.inlined_function_id == -1) {
+      Print(out);
+    } else {
+      SharedFunctionInfo* function = SharedFunctionInfo::cast(
+          deopt_data->LiteralArray()->get(inl.inlined_function_id));
+      Print(out, function);
+    }
+    out << " inlined at ";
+    inl.position.Print(out, code);
+  }
+}
+
+}  // namespace internal
+}  // namespace v8