Remove code that adjusts synced and copied flags in MergeTo.

src/frame-element.h

 // Copyright 2009 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 134 matching lines @@
   StaticType static_type() {
     return StaticType(StaticTypeField::decode(value_));
   }
 
   void set_static_type(StaticType static_type) {
     value_ = value_ & ~StaticTypeField::mask();
     value_ = value_ | StaticTypeField::encode(static_type.static_type_);
   }
 
   bool Equals(FrameElement other) {
-    if (value_ == other.value_) return true;
+    uint32_t masked_difference = (value_ ^ other.value_) & ~CopiedField::mask();
+    if (!masked_difference) {
+      // The elements are equal if they agree exactly except on copied field.
+      return true;
+    } else {
+      // If two constants have the same value, and agree otherwise, return true.
+       return !(masked_difference & ~DataField::mask()) &&
+              is_constant() &&
+              handle().is_identical_to(other.handle());
+    }
+  }
 
-    if (type() != other.type() ||
-        is_copied() != other.is_copied() ||
-        is_synced() != other.is_synced() ||
-        !(static_type() == other.static_type())) {
-      return false;
+  // Test if two FrameElements refer to the same memory or register location.
+  bool SameLocation(FrameElement* other) {
+    if (type() == other->type()) {
+      if (value_ == other->value_) return true;
+      if (is_constant() && handle().is_identical_to(other->handle())) {
+        return true;
+      }
     }
-
-    if (is_register()) {
-      if (!reg().is(other.reg())) return false;
-    } else if (is_constant()) {
-      if (!handle().is_identical_to(other.handle())) return false;
-    } else if (is_copy()) {
-      if (index() != other.index()) return false;
-    }
-
-    return true;
+    return false;
   }
 
   // Given a pair of non-null frame element pointers, return one of them
   // as an entry frame candidate or null if they are incompatible.
   FrameElement* Combine(FrameElement* other) {
     // If either is invalid, the result is.
     if (!is_valid()) return this;
     if (!other->is_valid()) return other;
 
-    // If they do not have the exact same location we reallocate.
-    bool not_same_location =
-        (type() != other->type()) ||
-        (is_register() && !reg().is(other->reg())) ||
-        (is_constant() && !handle().is_identical_to(other->handle())) ||
-        (is_copy() && index() != other->index());
-    if (not_same_location) return NULL;
-
+    if (!SameLocation(other)) return NULL;
     // If either is unsynced, the result is.  The result static type is
     // the merge of the static types.  It's safe to set it on one of the
     // frame elements, and harmless too (because we are only going to
     // merge the reaching frames and will ensure that the types are
     // coherent, and changing the static type does not emit code).
     FrameElement* result = is_synced() ? other : this;
     result->set_static_type(static_type().merge(other->static_type()));
     return result;
   }
 
@@ skipping 59 matching lines @@
   class CopiedField: public BitField<uint32_t, 6, 1> {};
   class SyncedField: public BitField<uint32_t, 7, 1> {};
   class DataField: public BitField<uint32_t, 8, 32 - 9> {};
 
   friend class VirtualFrame;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_FRAME_ELEMENT_H_