CpuProfile: rename HSourcePosition to SourcePosition and move it to compiler.*

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.h"
 #include "src/bailout-reason.h"
@@ skipping 12 matching lines @@
   ONLY_SINGLE_FUNCTION_LITERAL  // Only a single FunctionLiteral expression.
 };
 
 struct OffsetRange {
   OffsetRange(int from, int to) : from(from), to(to) {}
   int from;
   int to;
 };
 
 
+// This class encapsulates encoding and decoding of sources positions from
+// which hydrogen values originated.
+// When FLAG_track_hydrogen_positions is set this object encodes the
+// identifier of the inlining and absolute offset from the start of the
+// inlined function.
+// When the flag is not set we simply track absolute offset from the
+// script start.
+class SourcePosition {
+ public:
+  SourcePosition(const SourcePosition& other) : value_(other.value_) {}
+
+  static SourcePosition Unknown() {
+    return SourcePosition(RelocInfo::kNoPosition);
+  }
+
+  bool IsUnknown() const { return value_ == RelocInfo::kNoPosition; }
+
+  int position() const { return PositionField::decode(value_); }
+  void set_position(int position) {
+    if (FLAG_hydrogen_track_positions) {
+      value_ = static_cast<int>(PositionField::update(value_, position));
+    } else {
+      value_ = position;
+    }
+  }
+
+  int inlining_id() const { return InliningIdField::decode(value_); }
+  void set_inlining_id(int inlining_id) {
+    if (FLAG_hydrogen_track_positions) {
+      value_ = static_cast<int>(InliningIdField::update(value_, inlining_id));
+    }
+  }
+
+  int raw() const { return value_; }
+
+ private:
+  typedef BitField<int, 0, 9> InliningIdField;
+
+  // Offset from the start of the inlined function.
+  typedef BitField<int, 9, 23> PositionField;
+
+  explicit SourcePosition(int value) : value_(value) {}
+
+  friend class HPositionInfo;
+  friend class LCodeGenBase;
+
+  // If FLAG_hydrogen_track_positions is set contains bitfields InliningIdField
+  // and PositionField.
+  // Otherwise contains absolute offset from the script start.
+  int value_;

[Sven Panne, 2015/02/17 11:08:03]

What I meant in previous comments is that "int" is problematic here, effectively
reducing the portable field sizes. Consequently, the types of position and
inlining id are wrong, too, they should be unsigned. But then again we have the
problem with the kNoPosition hack, which stuffs in a negative value.

This should be handled in a separate CL.

+};
+
+
+std::ostream& operator<<(std::ostream& os, const SourcePosition& p);
+
+
 class InlinedFunctionInfo {
  public:
   explicit InlinedFunctionInfo(Handle<SharedFunctionInfo> shared)
       : shared_(shared), start_position_(shared->start_position()) {}
 
   Handle<SharedFunctionInfo> shared() const { return shared_; }
   int start_position() const { return start_position_; }
 
  private:
   Handle<SharedFunctionInfo> shared_;
@@ skipping 353 matching lines @@
     no_frame_ranges_ = NULL;
     return result;
   }
 
   List<InlinedFunctionInfo>* inlined_function_infos() {
     return inlined_function_infos_;
   }
   List<int>* inlining_id_to_function_id() {
     return inlining_id_to_function_id_;
   }
-  int TraceInlinedFunction(Handle<SharedFunctionInfo> shared, int raw_position);
+  int TraceInlinedFunction(Handle<SharedFunctionInfo> shared,
+                           SourcePosition raw_position);

[Sven Panne, 2015/02/17 11:08:03]

s/raw_position/position/

 
   Handle<Foreign> object_wrapper() {
     if (object_wrapper_.is_null()) {
       object_wrapper_ =
           isolate()->factory()->NewForeign(reinterpret_cast<Address>(this));
     }
     return object_wrapper_;
   }
 
   void AbortDueToDependencyChange() {
@@ skipping 383 matching lines @@
   Zone zone_;
   size_t info_zone_start_allocation_size_;
   base::ElapsedTimer timer_;
 
   DISALLOW_COPY_AND_ASSIGN(CompilationPhase);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_COMPILER_H_