revert r25736

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 21 matching lines @@
   V(Constant, CONSTANT, 0)                                           \
   V(Immediate, IMMEDIATE, 0)                                         \
   V(StackSlot, STACK_SLOT, 128)                                      \
   V(DoubleStackSlot, DOUBLE_STACK_SLOT, 128)                         \
   V(Register, REGISTER, RegisterConfiguration::kMaxGeneralRegisters) \
   V(DoubleRegister, DOUBLE_REGISTER, RegisterConfiguration::kMaxDoubleRegisters)
 
 class InstructionOperand : public ZoneObject {
  public:
   enum Kind {
+    INVALID,
     UNALLOCATED,
     CONSTANT,
     IMMEDIATE,
     STACK_SLOT,
     DOUBLE_STACK_SLOT,
     REGISTER,
     DOUBLE_REGISTER
   };
 
+  InstructionOperand() : value_(KindField::encode(INVALID)) {}
   InstructionOperand(Kind kind, int index) { ConvertTo(kind, index); }
 
   Kind kind() const { return KindField::decode(value_); }
   int index() const { return static_cast<int>(value_) >> KindField::kSize; }
 #define INSTRUCTION_OPERAND_PREDICATE(name, type, number) \
   bool Is##name() const { return kind() == type; }
   INSTRUCTION_OPERAND_LIST(INSTRUCTION_OPERAND_PREDICATE)
   INSTRUCTION_OPERAND_PREDICATE(Unallocated, UNALLOCATED, 0)
+  INSTRUCTION_OPERAND_PREDICATE(Ignored, INVALID, 0)
 #undef INSTRUCTION_OPERAND_PREDICATE
   bool Equals(const InstructionOperand* other) const {
     return value_ == other->value_;
   }
 
   void ConvertTo(Kind kind, int index) {
     if (kind == REGISTER || kind == DOUBLE_REGISTER) DCHECK(index >= 0);
     value_ = KindField::encode(kind);
     value_ |= index << KindField::kSize;
     DCHECK(this->index() == index);
@@ skipping 212 matching lines @@
   // The gap resolver marks moves as "in-progress" by clearing the
   // destination (but not the source).
   bool IsPending() const { return destination_ == NULL && source_ != NULL; }
 
   // True if this move a move into the given destination operand.
   bool Blocks(InstructionOperand* operand) const {
     return !IsEliminated() && source()->Equals(operand);
   }
 
   // A move is redundant if it's been eliminated, if its source and
-  // destination are the same, or if its destination is  constant.
+  // destination are the same, or if its destination is unneeded or constant.
   bool IsRedundant() const {
-    return IsEliminated() || source_->Equals(destination_) ||
+    return IsEliminated() || source_->Equals(destination_) || IsIgnored() ||
            (destination_ != NULL && destination_->IsConstant());
   }
 
+  bool IsIgnored() const {
+    return destination_ != NULL && destination_->IsIgnored();
+  }
+
   // We clear both operands to indicate move that's been eliminated.
   void Eliminate() { source_ = destination_ = NULL; }
   bool IsEliminated() const {
     DCHECK(source_ != NULL || destination_ == NULL);
     return source_ == NULL;
   }
 
  private:
   InstructionOperand* source_;
   InstructionOperand* destination_;
@@ skipping 27 matching lines @@
     DCHECK(op->kind() == kOperandKind);
     return reinterpret_cast<const SubKindOperand*>(op);
   }
 
   static void SetUpCache();
   static void TearDownCache();
 
  private:
   static SubKindOperand* cache;
 
-  SubKindOperand() : InstructionOperand(kOperandKind, 0) {}  // For the caches.
+  SubKindOperand() : InstructionOperand() {}
   explicit SubKindOperand(int index)
       : InstructionOperand(kOperandKind, index) {}
 };
 
 
 #define INSTRUCTION_TYPEDEF_SUBKIND_OPERAND_CLASS(name, type, number) \
   typedef SubKindOperand<InstructionOperand::type, number> name##Operand;
 INSTRUCTION_OPERAND_LIST(INSTRUCTION_TYPEDEF_SUBKIND_OPERAND_CLASS)
 #undef INSTRUCTION_TYPEDEF_SUBKIND_OPERAND_CLASS
 
@@ skipping 730 matching lines @@
 
 
 std::ostream& operator<<(std::ostream& os,
                          const PrintableInstructionSequence& code);
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_INSTRUCTION_H_