Environment bookkeping has linear time complexity now, not a quadratic one.

src/data-flow.h

 // Copyright 2012 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 183 matching lines @@
 #endif
 
  private:
   int length_;
   int data_length_;
   uint32_t* data_;
 };
 
 class GrowableBitVector BASE_EMBEDDED {
  public:
+  class Iterator BASE_EMBEDDED {
+   public:
+    Iterator(const GrowableBitVector* target, Zone* zone)
+        : it_(target->bits_ == NULL
+              ? new(zone) BitVector(1, zone)
+              : target->bits_) { }
+    bool Done() const { return it_.Done(); }
+    void Advance() { it_.Advance(); }
+    int Current() const { return it_.Current(); }
+   private:
+    BitVector::Iterator it_;
+  };
+
   GrowableBitVector() : bits_(NULL) { }
 
   bool Contains(int value) const {
     if (!InBitsRange(value)) return false;
     return bits_->Contains(value);
   }
 
   void Add(int value, Zone* zone) {
     EnsureCapacity(value, zone);
     bits_->Add(value);
   }
 
+  void Union(const GrowableBitVector& other, Zone* zone) {
+    for (Iterator it(&other, zone); !it.Done(); it.Advance()) {
+      Add(it.Current(), zone);
+    }
+  }
+
+  void Clear() { if (bits_ != NULL) bits_->Clear(); }
+
  private:
   static const int kInitialLength = 1024;
 
   bool InBitsRange(int value) const {
     return bits_ != NULL && bits_->length() > value;
   }
 
   void EnsureCapacity(int value, Zone* zone) {
     if (InBitsRange(value)) return;
     int new_length = bits_ == NULL ? kInitialLength : bits_->length();
     while (new_length <= value) new_length *= 2;
     BitVector* new_bits = new(zone) BitVector(new_length, zone);
     if (bits_ != NULL) new_bits->CopyFrom(*bits_);
     bits_ = new_bits;
   }
 
   BitVector* bits_;
 };
 
 
 } }  // namespace v8::internal
 
 
 #endif  // V8_DATAFLOW_H_