Various cleanups in check elimination.

src/unique.h

 // Copyright 2013 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_UNIQUE_H_
 #define V8_HYDROGEN_UNIQUE_H_
 
 #include "handles.h"
 #include "objects.h"
 #include "utils.h"
@@ skipping 116 matching lines @@
   friend class SideEffectsTracker;
 };
 
 
 template <typename T>
 class UniqueSet V8_FINAL : public ZoneObject {
  public:
   // Constructor. A new set will be empty.
   UniqueSet() : size_(0), capacity_(0), array_(NULL) { }
 
+  // Capacity constructor. A new set will be empty.
+  UniqueSet(int capacity, Zone* zone)
+      : size_(0), capacity_(capacity),
+        array_(zone->NewArray<Unique<T> >(capacity)) {
+    ASSERT(capacity <= kMaxCapacity);
+  }
+
+  // Singleton constructor.
+  UniqueSet(Unique<T> uniq, Zone* zone)
+      : size_(1), capacity_(1), array_(zone->NewArray<Unique<T> >(1)) {
+    array_[0] = uniq;
+  }
+
   // Add a new element to this unique set. Mutates this set. O(|this|).
   void Add(Unique<T> uniq, Zone* zone) {
     ASSERT(uniq.IsInitialized());
     // Keep the set sorted by the {raw_address} of the unique elements.
     for (int i = 0; i < size_; i++) {
       if (array_[i] == uniq) return;
       if (array_[i].raw_address_ > uniq.raw_address_) {
         // Insert in the middle.
         Grow(size_ + 1, zone);
         for (int j = size_ - 1; j >= i; j--) array_[j + 1] = array_[j];
@@ skipping 24 matching lines @@
     for (int i = 0; i < this->size_; i++) {
       if (this->array_[i] != that->array_[i]) return false;
     }
     return true;
   }
 
   // Check whether this set contains the given element. O(|this|)
   // TODO(titzer): use binary search for large sets to make this O(log|this|)
   template <typename U>
   bool Contains(const Unique<U> elem) const {
-    for (int i = 0; i < size_; i++) {
-      if (this->array_[i] == elem) return true;
+    for (int i = 0; i < this->size_; ++i) {
+      Unique<T> cand = this->array_[i];
+      if (cand.raw_address_ >= elem.raw_address_) {
+        return cand.raw_address_ == elem.raw_address_;
+      }
     }
     return false;
   }
 
   // Check if this set is a subset of the given set. O(|this| + |that|).
   bool IsSubset(const UniqueSet<T>* that) const {
     if (that->size_ < this->size_) return false;
     int j = 0;
     for (int i = 0; i < this->size_; i++) {
       Unique<T> sought = this->array_[i];
       while (true) {
         if (sought == that->array_[j++]) break;
         // Fail whenever there are more elements in {this} than {that}.
         if ((this->size_ - i) > (that->size_ - j)) return false;
       }
     }
     return true;
   }
 
   // Returns a new set representing the intersection of this set and the other.
   // O(|this| + |that|).
-  UniqueSet<T>* Intersect(UniqueSet<T>* that, Zone* zone) const {
+  UniqueSet<T>* Intersect(const UniqueSet<T>* that, Zone* zone) const {
     if (that->size_ == 0 || this->size_ == 0) return new(zone) UniqueSet<T>();
 
-    UniqueSet<T>* out = new(zone) UniqueSet<T>();
-    out->Grow(Min(this->size_, that->size_), zone);
+    UniqueSet<T>* out = new(zone) UniqueSet<T>(
+        Min(this->size_, that->size_), zone);
 
     int i = 0, j = 0, k = 0;
     while (i < this->size_ && j < that->size_) {
       Unique<T> a = this->array_[i];
       Unique<T> b = that->array_[j];
       if (a == b) {
         out->array_[k++] = a;
         i++;
         j++;
       } else if (a.raw_address_ < b.raw_address_) {
         i++;
       } else {
         j++;
       }
     }
 
     out->size_ = k;
     return out;
   }
 
   // Returns a new set representing the union of this set and the other.
   // O(|this| + |that|).
-  UniqueSet<T>* Union(UniqueSet<T>* that, Zone* zone) const {
+  UniqueSet<T>* Union(const UniqueSet<T>* that, Zone* zone) const {
     if (that->size_ == 0) return this->Copy(zone);
     if (this->size_ == 0) return that->Copy(zone);
 
-    UniqueSet<T>* out = new(zone) UniqueSet<T>();
-    out->Grow(this->size_ + that->size_, zone);
+    UniqueSet<T>* out = new(zone) UniqueSet<T>(
+        this->size_ + that->size_, zone);
 
     int i = 0, j = 0, k = 0;
     while (i < this->size_ && j < that->size_) {
       Unique<T> a = this->array_[i];
       Unique<T> b = that->array_[j];
       if (a == b) {
         out->array_[k++] = a;
         i++;
         j++;
       } else if (a.raw_address_ < b.raw_address_) {
         out->array_[k++] = a;
         i++;
       } else {
         out->array_[k++] = b;
         j++;
       }
     }
 
     while (i < this->size_) out->array_[k++] = this->array_[i++];
     while (j < that->size_) out->array_[k++] = that->array_[j++];
 
     out->size_ = k;
     return out;
   }
 
   // Makes an exact copy of this set. O(|this|).
   UniqueSet<T>* Copy(Zone* zone) const {
-    UniqueSet<T>* copy = new(zone) UniqueSet<T>();
+    UniqueSet<T>* copy = new(zone) UniqueSet<T>(this->size_, zone);
     copy->size_ = this->size_;
-    copy->capacity_ = this->size_;
-    copy->array_ = zone->NewArray<Unique<T> >(this->size_);
     memcpy(copy->array_, this->array_, this->size_ * sizeof(Unique<T>));
     return copy;
   }
 
   void Clear() {
     size_ = 0;
   }
 
   inline int size() const {
     return size_;
@@ skipping 26 matching lines @@
       capacity_ = new_capacity;
       array_ = new_array;
     }
   }
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_UNIQUE_H_