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

src/hydrogen-instructions.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_HYDROGEN_INSTRUCTIONS_H_
 #define V8_HYDROGEN_INSTRUCTIONS_H_
 
 #include <cstring>
 #include <iosfwd>
 
@@ skipping 394 matching lines @@
 
   HValue* base_;
   int offset_;
   int scale_;
 };
 
 
 typedef EnumSet<GVNFlag, int32_t> GVNFlagSet;
 
 
-// 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 HSourcePosition {
- public:
-  HSourcePosition(const HSourcePosition& other) : value_(other.value_) { }
-
-  static HSourcePosition Unknown() {
-    return HSourcePosition(RelocInfo::kNoPosition);
-  }
-  static HSourcePosition FromRaw(int raw_value) {
-    return HSourcePosition(raw_value);
-  }
-
-  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 HSourcePosition(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_;
-};
-
-
-std::ostream& operator<<(std::ostream& os, const HSourcePosition& p);
-
-
 class HValue : public ZoneObject {
  public:
   static const int kNoNumber = -1;
 
   enum Flag {
     kFlexibleRepresentation,
     kCannotBeTagged,
     // Participate in Global Value Numbering, i.e. elimination of
     // unnecessary recomputations. If an instruction sets this flag, it must
     // implement DataEquals(), which will be used to determine if other
@@ skipping 75 matching lines @@
         id_(kNoNumber),
         type_(type),
         use_list_(NULL),
         range_(NULL),
 #ifdef DEBUG
         range_poisoned_(false),
 #endif
         flags_(0) {}
   virtual ~HValue() {}
 
-  virtual HSourcePosition position() const {
-    return HSourcePosition::Unknown();
-  }
-  virtual HSourcePosition operand_position(int index) const {
+  virtual SourcePosition position() const { return SourcePosition::Unknown(); }
+  virtual SourcePosition operand_position(int index) const {
     return position();
   }
 
   HBasicBlock* block() const { return block_; }
   void SetBlock(HBasicBlock* block);
 
   // Note: Never call this method for an unlinked value.
   Isolate* isolate() const;
 
   int id() const { return id_; }
@@ skipping 449 matching lines @@
 // the HInstruction in the compact form. Uses tagging to distinguish between
 // case when only instruction's position is available and case when operands'
 // positions are also available.
 // In the first case it contains intruction's position as a tagged value.
 // In the second case it points to an array which contains instruction's
 // position and operands' positions.
 class HPositionInfo {
  public:
   explicit HPositionInfo(int pos) : data_(TagPosition(pos)) { }
 
-  HSourcePosition position() const {
+  SourcePosition position() const {
     if (has_operand_positions()) {
       return operand_positions()[kInstructionPosIndex];
     }
-    return HSourcePosition(static_cast<int>(UntagPosition(data_)));
+    return SourcePosition(static_cast<int>(UntagPosition(data_)));
   }
 
-  void set_position(HSourcePosition pos) {
+  void set_position(SourcePosition pos) {
     if (has_operand_positions()) {
       operand_positions()[kInstructionPosIndex] = pos;
     } else {
       data_ = TagPosition(pos.raw());
     }
   }
 
   void ensure_storage_for_operand_positions(Zone* zone, int operand_count) {
     if (has_operand_positions()) {
       return;
     }
 
     const int length = kFirstOperandPosIndex + operand_count;
-    HSourcePosition* positions =
-        zone->NewArray<HSourcePosition>(length);
+    SourcePosition* positions = zone->NewArray<SourcePosition>(length);
     for (int i = 0; i < length; i++) {
-      positions[i] = HSourcePosition::Unknown();
+      positions[i] = SourcePosition::Unknown();
     }
 
-    const HSourcePosition pos = position();
+    const SourcePosition pos = position();
     data_ = reinterpret_cast<intptr_t>(positions);
     set_position(pos);
 
     DCHECK(has_operand_positions());
   }
 
-  HSourcePosition operand_position(int idx) const {
+  SourcePosition operand_position(int idx) const {
     if (!has_operand_positions()) {
       return position();
     }
     return *operand_position_slot(idx);
   }
 
-  void set_operand_position(int idx, HSourcePosition pos) {
+  void set_operand_position(int idx, SourcePosition pos) {
     *operand_position_slot(idx) = pos;
   }
 
  private:
   static const intptr_t kInstructionPosIndex = 0;
   static const intptr_t kFirstOperandPosIndex = 1;
 
-  HSourcePosition* operand_position_slot(int idx) const {
+  SourcePosition* operand_position_slot(int idx) const {
     DCHECK(has_operand_positions());
     return &(operand_positions()[kFirstOperandPosIndex + idx]);
   }
 
   bool has_operand_positions() const {
     return !IsTaggedPosition(data_);
   }
 
-  HSourcePosition* operand_positions() const {
+  SourcePosition* operand_positions() const {
     DCHECK(has_operand_positions());
-    return reinterpret_cast<HSourcePosition*>(data_);
+    return reinterpret_cast<SourcePosition*>(data_);
   }
 
   static const intptr_t kPositionTag = 1;
   static const intptr_t kPositionShift = 1;
   static bool IsTaggedPosition(intptr_t val) {
     return (val & kPositionTag) != 0;
   }
   static intptr_t UntagPosition(intptr_t val) {
     DCHECK(IsTaggedPosition(val));
     return val >> kPositionShift;
@@ skipping 27 matching lines @@
   }
 
   void InsertAfter(HInstruction* previous);
 
   template<class T> T* Append(T* instr) {
     instr->InsertAfter(this);
     return instr;
   }
 
   // The position is a write-once variable.
-  HSourcePosition position() const OVERRIDE {
-    return HSourcePosition(position_.position());
+  SourcePosition position() const OVERRIDE {
+    return SourcePosition(position_.position());
   }
   bool has_position() const {
     return !position().IsUnknown();
   }
-  void set_position(HSourcePosition position) {
+  void set_position(SourcePosition position) {
     DCHECK(!has_position());
     DCHECK(!position.IsUnknown());
     position_.set_position(position);
   }
 
-  HSourcePosition operand_position(int index) const OVERRIDE {
-    const HSourcePosition pos = position_.operand_position(index);
+  SourcePosition operand_position(int index) const OVERRIDE {
+    const SourcePosition pos = position_.operand_position(index);
     return pos.IsUnknown() ? position() : pos;
   }
-  void set_operand_position(Zone* zone, int index, HSourcePosition pos) {
+  void set_operand_position(Zone* zone, int index, SourcePosition pos) {
     DCHECK(0 <= index && index < OperandCount());
     position_.ensure_storage_for_operand_positions(zone, OperandCount());
     position_.set_operand_position(index, pos);
   }
 
   bool Dominates(HInstruction* other);
   bool CanTruncateToSmi() const { return CheckFlag(kTruncatingToSmi); }
   bool CanTruncateToInt32() const { return CheckFlag(kTruncatingToInt32); }
 
   virtual LInstruction* CompileToLithium(LChunkBuilder* builder) = 0;
@@ skipping 2116 matching lines @@
   HType CalculateInferredType() OVERRIDE;
   int OperandCount() const OVERRIDE { return inputs_.length(); }
   HValue* OperandAt(int index) const OVERRIDE { return inputs_[index]; }
   HValue* GetRedundantReplacement();
   void AddInput(HValue* value);
   bool HasRealUses();
 
   bool IsReceiver() const { return merged_index_ == 0; }
   bool HasMergedIndex() const { return merged_index_ != kInvalidMergedIndex; }
 
-  HSourcePosition position() const OVERRIDE;
+  SourcePosition position() const OVERRIDE;
 
   int merged_index() const { return merged_index_; }
 
   InductionVariableData* induction_variable_data() {
     return induction_variable_data_;
   }
   bool IsInductionVariable() {
     return induction_variable_data_ != NULL;
   }
   bool IsLimitedInductionVariable() {
@@ skipping 548 matching lines @@
 
   virtual bool IsCommutative() const { return false; }
 
   std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
 
   Representation RequiredInputRepresentation(int index) OVERRIDE {
     if (index == 0) return Representation::Tagged();
     return representation();
   }
 
-  void SetOperandPositions(Zone* zone,
-                           HSourcePosition left_pos,
-                           HSourcePosition right_pos) {
+  void SetOperandPositions(Zone* zone, SourcePosition left_pos,
+                           SourcePosition right_pos) {
     set_operand_position(zone, 1, left_pos);
     set_operand_position(zone, 2, right_pos);
   }
 
   bool RightIsPowerOf2() {
     if (!right()->IsInteger32Constant()) return false;
     int32_t value = right()->GetInteger32Constant();
     if (value < 0) {
       return base::bits::IsPowerOfTwo32(static_cast<uint32_t>(-value));
     }
@@ skipping 437 matching lines @@
     return representation();
   }
   Representation observed_input_representation(int index) OVERRIDE {
     return observed_input_representation_[index];
   }
 
   bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE;
 
   std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
 
-  void SetOperandPositions(Zone* zone,
-                           HSourcePosition left_pos,
-                           HSourcePosition right_pos) {
+  void SetOperandPositions(Zone* zone, SourcePosition left_pos,
+                           SourcePosition right_pos) {
     set_operand_position(zone, 0, left_pos);
     set_operand_position(zone, 1, right_pos);
   }
 
   DECLARE_CONCRETE_INSTRUCTION(CompareNumericAndBranch)
 
  private:
   HCompareNumericAndBranch(HValue* left,
                            HValue* right,
                            Token::Value token,
@@ skipping 3656 matching lines @@
 };
 
 
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_