Change the algorithm and generated code for parallel moves on IA32.

src/lithium-allocator.h

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 303 matching lines @@
     value_ |= PolicyField::encode(policy);
     value_ |= LifetimeField::encode(lifetime);
     value_ |= fixed_index << kFixedIndexShift;
     ASSERT(this->fixed_index() == fixed_index);
   }
 };
 
 
 class LMoveOperands BASE_EMBEDDED {
  public:
-  LMoveOperands(LOperand* from, LOperand* to) : from_(from), to_(to) { }
-
-  LOperand* from() const { return from_; }
-  LOperand* to() const { return to_; }
-  bool IsRedundant() const {
-    return IsEliminated() || from_->Equals(to_) || IsIgnored();
-  }
-  bool IsEliminated() const { return from_ == NULL; }
-  bool IsIgnored() const {
-    if (to_ != NULL && to_->IsUnallocated() &&
-      LUnallocated::cast(to_)->HasIgnorePolicy()) {
-      return true;
-    }
-    return false;
+  LMoveOperands(LOperand* source, LOperand* destination)
+      : source_(source), destination_(destination) {
   }
 
-  void Eliminate() { from_ = to_ = NULL; }
+  LOperand* source() const { return source_; }
+  void set_source(LOperand* operand) { source_ = operand; }
+
+  LOperand* destination() const { return destination_; }
+  void set_destination(LOperand* operand) { destination_ = operand; }
+
+  // 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(LOperand* 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 unneeded.
+  bool IsRedundant() const {
+    return IsEliminated() || source_->Equals(destination_) || IsIgnored();
+  }
+
+  bool IsIgnored() const {
+    return destination_ != NULL &&
+        destination_->IsUnallocated() &&
+        LUnallocated::cast(destination_)->HasIgnorePolicy();
+  }
+
+  // We clear both operands to indicate move that's been eliminated.
+  void Eliminate() { source_ = destination_ = NULL; }
+  bool IsEliminated() const { return source_ == NULL; }

[fschneider, 2011/01/17 09:44:16]

maybe ASSERT(destination_ == NULL) here, or 

return source_ == NULL && destination_ == NULL;

[Kevin Millikin (Chromium), 2011/01/17 10:13:09]

I'll assert (source_ != NULL || destination_ == NULL).

 
  private:
-  LOperand* from_;
-  LOperand* to_;
+  LOperand* source_;
+  LOperand* destination_;
 };
 
 
 class LConstantOperand: public LOperand {
  public:
   static LConstantOperand* Create(int index) {
     ASSERT(index >= 0);
     if (index < kNumCachedOperands) return &cache[index];
     return new LConstantOperand(index);
   }
@@ skipping 672 matching lines @@
 
   bool has_osr_entry_;
 
   DISALLOW_COPY_AND_ASSIGN(LAllocator);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_LITHIUM_ALLOCATOR_H_