Reland: [turbofan] add MachineType to AllocatedOperand

src/compiler/instruction.h

 // Copyright 2014 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_INSTRUCTION_H_
 #define V8_COMPILER_INSTRUCTION_H_
 
 #include <deque>
 #include <iosfwd>
 #include <map>
@@ skipping 32 matching lines @@
   INSTRUCTION_OPERAND_PREDICATE(Constant, CONSTANT)
   INSTRUCTION_OPERAND_PREDICATE(Immediate, IMMEDIATE)
   INSTRUCTION_OPERAND_PREDICATE(Allocated, ALLOCATED)
 #undef INSTRUCTION_OPERAND_PREDICATE
 
   inline bool IsRegister() const;
   inline bool IsDoubleRegister() const;
   inline bool IsStackSlot() const;
   inline bool IsDoubleStackSlot() const;
 
-  // Useful for map/set keys.
-  bool operator<(const InstructionOperand& op) const {
-    return value_ < op.value_;
-  }
-
-  bool operator==(const InstructionOperand& op) const {
-    return value_ == op.value_;
-  }
-
-  bool operator!=(const InstructionOperand& op) const {
-    return value_ != op.value_;
-  }
-
   template <typename SubKindOperand>
   static SubKindOperand* New(Zone* zone, const SubKindOperand& op) {
     void* buffer = zone->New(sizeof(op));
     return new (buffer) SubKindOperand(op);
   }
 
   static void ReplaceWith(InstructionOperand* dest,
                           const InstructionOperand* src) {
     *dest = *src;
   }
 
+  bool Equals(const InstructionOperand& that) const {
+    return this->value_ == that.value_;
+  }
+
+  bool Compare(const InstructionOperand& that) const {
+    return this->value_ < that.value_;
+  }
+
+  bool EqualsModuloType(const InstructionOperand& that) const {
+    return this->GetValueModuloType() == that.GetValueModuloType();
+  }
+
+  bool CompareModuloType(const InstructionOperand& that) const {
+    return this->GetValueModuloType() < that.GetValueModuloType();
+  }
+
  protected:
   explicit InstructionOperand(Kind kind) : value_(KindField::encode(kind)) {}
 
+  inline uint64_t GetValueModuloType() const;
+
   class KindField : public BitField64<Kind, 0, 3> {};
 
   uint64_t value_;
 };
 
+
 struct PrintableInstructionOperand {
   const RegisterConfiguration* register_configuration_;
   InstructionOperand op_;
 };
 
+
 std::ostream& operator<<(std::ostream& os,
                          const PrintableInstructionOperand& op);
 
+
 #define INSTRUCTION_OPERAND_CASTS(OperandType, OperandKind)      \
                                                                  \
   static OperandType* cast(InstructionOperand* op) {             \
     DCHECK_EQ(OperandKind, op->kind());                          \
     return static_cast<OperandType*>(op);                        \
   }                                                              \
                                                                  \
   static const OperandType* cast(const InstructionOperand* op) { \
     DCHECK_EQ(OperandKind, op->kind());                          \
     return static_cast<const OperandType*>(op);                  \
@@ skipping 236 matching lines @@
   INSTRUCTION_OPERAND_CASTS(ImmediateOperand, IMMEDIATE);
 
   STATIC_ASSERT(KindField::kSize == 3);
   class TypeField : public BitField64<ImmediateType, 3, 1> {};
   class ValueField : public BitField64<int32_t, 32, 32> {};
 };
 
 
 class AllocatedOperand : public InstructionOperand {
  public:
+  // TODO(dcarney): machine_type makes this now redundant. Just need to know is
+  // the operand is a slot or a register.
   enum AllocatedKind {
     STACK_SLOT,
     DOUBLE_STACK_SLOT,
     REGISTER,
     DOUBLE_REGISTER
   };
 
-  AllocatedOperand(AllocatedKind kind, int index)
+  AllocatedOperand(AllocatedKind kind, MachineType machine_type, int index)
       : InstructionOperand(ALLOCATED) {
     DCHECK_IMPLIES(kind == REGISTER || kind == DOUBLE_REGISTER, index >= 0);
+    DCHECK(IsSupportedMachineType(machine_type));
     value_ |= AllocatedKindField::encode(kind);
+    value_ |= MachineTypeField::encode(machine_type);
     value_ |= static_cast<int64_t>(index) << IndexField::kShift;
   }
 
   int index() const {
     return static_cast<int64_t>(value_) >> IndexField::kShift;
   }
 
   AllocatedKind allocated_kind() const {
     return AllocatedKindField::decode(value_);
   }
 
-  static AllocatedOperand* New(Zone* zone, AllocatedKind kind, int index) {
-    return InstructionOperand::New(zone, AllocatedOperand(kind, index));
+  MachineType machine_type() const { return MachineTypeField::decode(value_); }
+
+  static AllocatedOperand* New(Zone* zone, AllocatedKind kind,
+                               MachineType machine_type, int index) {
+    return InstructionOperand::New(zone,
+                                   AllocatedOperand(kind, machine_type, index));
+  }
+
+  static bool IsSupportedMachineType(MachineType machine_type) {
+    if (RepresentationOf(machine_type) != machine_type) return false;
+    switch (machine_type) {
+      case kRepWord32:
+      case kRepWord64:
+      case kRepFloat32:
+      case kRepFloat64:
+      case kRepTagged:
+        return true;
+      default:
+        return false;
+    }
   }
 
   INSTRUCTION_OPERAND_CASTS(AllocatedOperand, ALLOCATED);
 
   STATIC_ASSERT(KindField::kSize == 3);
   class AllocatedKindField : public BitField64<AllocatedKind, 3, 2> {};
+  class MachineTypeField : public BitField64<MachineType, 5, 16> {};
   class IndexField : public BitField64<int32_t, 35, 29> {};
 };
 
 
 #undef INSTRUCTION_OPERAND_CASTS
 
 
 #define ALLOCATED_OPERAND_LIST(V)       \
   V(StackSlot, STACK_SLOT)              \
   V(DoubleStackSlot, DOUBLE_STACK_SLOT) \
   V(Register, REGISTER)                 \
   V(DoubleRegister, DOUBLE_REGISTER)
 
 
 #define ALLOCATED_OPERAND_IS(SubKind, kOperandKind)          \
   bool InstructionOperand::Is##SubKind() const {             \
     return IsAllocated() &&                                  \
            AllocatedOperand::cast(this)->allocated_kind() == \
                AllocatedOperand::kOperandKind;               \
   }
 ALLOCATED_OPERAND_LIST(ALLOCATED_OPERAND_IS)
 #undef ALLOCATED_OPERAND_IS
 
 
+// TODO(dcarney): these subkinds are now pretty useless, nuke.
 #define ALLOCATED_OPERAND_CLASS(SubKind, kOperandKind)                       \
   class SubKind##Operand final : public AllocatedOperand {                   \
    public:                                                                   \
-    explicit SubKind##Operand(int index)                                     \
-        : AllocatedOperand(kOperandKind, index) {}                           \
+    explicit SubKind##Operand(MachineType machine_type, int index)           \
+        : AllocatedOperand(kOperandKind, machine_type, index) {}             \
                                                                              \
-    static SubKind##Operand* New(Zone* zone, int index) {                    \
-      return InstructionOperand::New(zone, SubKind##Operand(index));         \
+    static SubKind##Operand* New(Zone* zone, MachineType machine_type,       \
+                                 int index) {                                \
+      return InstructionOperand::New(zone,                                   \
+                                     SubKind##Operand(machine_type, index)); \
     }                                                                        \
                                                                              \
     static SubKind##Operand* cast(InstructionOperand* op) {                  \
       DCHECK_EQ(kOperandKind, AllocatedOperand::cast(op)->allocated_kind()); \
       return reinterpret_cast<SubKind##Operand*>(op);                        \
     }                                                                        \
                                                                              \
     static const SubKind##Operand* cast(const InstructionOperand* op) {      \
       DCHECK_EQ(kOperandKind, AllocatedOperand::cast(op)->allocated_kind()); \
       return reinterpret_cast<const SubKind##Operand*>(op);                  \
     }                                                                        \
                                                                              \
     static SubKind##Operand cast(const InstructionOperand& op) {             \
       DCHECK_EQ(kOperandKind, AllocatedOperand::cast(op).allocated_kind());  \
       return *static_cast<const SubKind##Operand*>(&op);                     \
     }                                                                        \
   };
 ALLOCATED_OPERAND_LIST(ALLOCATED_OPERAND_CLASS)
 #undef ALLOCATED_OPERAND_CLASS
 
 
+uint64_t InstructionOperand::GetValueModuloType() const {
+  if (IsAllocated()) {
+    // TODO(dcarney): put machine type last and mask.
+    return AllocatedOperand::MachineTypeField::update(this->value_, kMachNone);
+  }
+  return this->value_;
+}
+
+
+// Required for maps that don't care about machine type.
+struct CompareOperandModuloType {
+  bool operator()(const InstructionOperand& a,
+                  const InstructionOperand& b) const {
+    return a.CompareModuloType(b);
+  }
+};
+
+
 class MoveOperands final : public ZoneObject {
  public:
   MoveOperands(const InstructionOperand& source,
                const InstructionOperand& destination)
       : source_(source), destination_(destination) {
     DCHECK(!source.IsInvalid() && !destination.IsInvalid());
   }
 
   const InstructionOperand& source() const { return source_; }
   InstructionOperand& source() { return source_; }
   void set_source(const InstructionOperand& operand) { source_ = operand; }
 
   const InstructionOperand& destination() const { return destination_; }
   InstructionOperand& destination() { return destination_; }
   void set_destination(const InstructionOperand& operand) {
     destination_ = operand;
   }
 
   // The gap resolver marks moves as "in-progress" by clearing the
   // destination (but not the source).
   bool IsPending() const {
     return destination_.IsInvalid() && !source_.IsInvalid();
   }
   void SetPending() { destination_ = InstructionOperand(); }
 
   // True if this move a move into the given destination operand.
   bool Blocks(const InstructionOperand& operand) const {
-    return !IsEliminated() && source() == operand;
+    return !IsEliminated() && source().EqualsModuloType(operand);
   }
 
   // A move is redundant if it's been eliminated or if its source and
   // destination are the same.
   bool IsRedundant() const {
     DCHECK_IMPLIES(!destination_.IsInvalid(), !destination_.IsConstant());
-    return IsEliminated() || source_ == destination_;
+    return IsEliminated() || source_.EqualsModuloType(destination_);
   }
 
   // We clear both operands to indicate move that's been eliminated.
   void Eliminate() { source_ = destination_ = InstructionOperand(); }
   bool IsEliminated() const {
     DCHECK_IMPLIES(source_.IsInvalid(), destination_.IsInvalid());
     return source_.IsInvalid();
   }
 
  private:
@@ skipping 67 matching lines @@
 
  private:
   friend std::ostream& operator<<(std::ostream& os, const ReferenceMap& pm);
 
   ZoneVector<InstructionOperand> reference_operands_;
   int instruction_position_;
 };
 
 std::ostream& operator<<(std::ostream& os, const ReferenceMap& pm);
 
-class Instruction {
+class Instruction final {
  public:
   size_t OutputCount() const { return OutputCountField::decode(bit_field_); }
   const InstructionOperand* OutputAt(size_t i) const {
     DCHECK(i < OutputCount());
     return &operands_[i];
   }
   InstructionOperand* OutputAt(size_t i) {
     DCHECK(i < OutputCount());
     return &operands_[i];
   }
@@ skipping 104 matching lines @@
 
   const ParallelMove* GetParallelMove(GapPosition pos) const {
     return parallel_moves_[pos];
   }
 
   bool AreMovesRedundant() const;
 
   ParallelMove* const* parallel_moves() const { return &parallel_moves_[0]; }
   ParallelMove** parallel_moves() { return &parallel_moves_[0]; }
 
- protected:
+ private:
   explicit Instruction(InstructionCode opcode);
 
- private:
   Instruction(InstructionCode opcode, size_t output_count,
               InstructionOperand* outputs, size_t input_count,
               InstructionOperand* inputs, size_t temp_count,
               InstructionOperand* temps);
 
   typedef BitField<size_t, 0, 8> OutputCountField;
   typedef BitField<size_t, 8, 16> InputCountField;
   typedef BitField<size_t, 24, 6> TempCountField;
   typedef BitField<bool, 30, 1> IsCallField;
 
   InstructionCode opcode_;
   uint32_t bit_field_;
   ParallelMove* parallel_moves_[2];
   ReferenceMap* reference_map_;
   InstructionOperand operands_[1];
 
- private:
   DISALLOW_COPY_AND_ASSIGN(Instruction);
 };
 
 
 struct PrintableInstruction {
   const RegisterConfiguration* register_configuration_;
   const Instruction* instr_;
 };
 std::ostream& operator<<(std::ostream& os, const PrintableInstruction& instr);
 
@@ skipping 287 matching lines @@
     return instruction_blocks_->at(block->loop_end().ToSize() - 1)
         ->last_instruction_index();
   }
 
   const InstructionBlock* InstructionBlockAt(RpoNumber rpo_number) const {
     return instruction_blocks_->at(rpo_number.ToSize());
   }
 
   const InstructionBlock* GetInstructionBlock(int instruction_index) const;
 
-  bool IsReference(int virtual_register) const;
-  bool IsDouble(int virtual_register) const;
+  static MachineType DefaultRepresentation() {
+    return kPointerSize == 8 ? kRepWord64 : kRepWord32;
+  }
+  MachineType GetRepresentation(int virtual_register) const;
+  void MarkAsRepresentation(MachineType machine_type, int virtual_register);
 
-  void MarkAsReference(int virtual_register);
-  void MarkAsDouble(int virtual_register);
+  bool IsReference(int virtual_register) const {
+    return GetRepresentation(virtual_register) == kRepTagged;
+  }
+  bool IsFloat(int virtual_register) const {
+    switch (GetRepresentation(virtual_register)) {
+      case kRepFloat32:
+      case kRepFloat64:
+        return true;
+      default:
+        return false;
+    }
+  }
 
   Instruction* GetBlockStart(RpoNumber rpo) const;
 
   typedef InstructionDeque::const_iterator const_iterator;
   const_iterator begin() const { return instructions_.begin(); }
   const_iterator end() const { return instructions_.end(); }
   const InstructionDeque& instructions() const { return instructions_; }
 
   Instruction* InstructionAt(int index) const {
     DCHECK(index >= 0);
@@ skipping 82 matching lines @@
   Isolate* isolate_;
   Zone* const zone_;
   InstructionBlocks* const instruction_blocks_;
   SourcePositionMap source_positions_;
   IntVector block_starts_;
   ConstantMap constants_;
   Immediates immediates_;
   InstructionDeque instructions_;
   int next_virtual_register_;
   ReferenceMapDeque reference_maps_;
-  VirtualRegisterSet doubles_;
-  VirtualRegisterSet references_;
+  ZoneVector<MachineType> representations_;
   DeoptimizationVector deoptimization_entries_;
 
   DISALLOW_COPY_AND_ASSIGN(InstructionSequence);
 };
 
 
 struct PrintableInstructionSequence {
   const RegisterConfiguration* register_configuration_;
   const InstructionSequence* sequence_;
 };
 
 
 std::ostream& operator<<(std::ostream& os,
                          const PrintableInstructionSequence& code);
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_INSTRUCTION_H_