[Isolates] Merge crankshaft (r5922 from bleeding_edge).

src/utils.h

 // Copyright 2006-2008 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 208 matching lines @@
   // Returns a uint32_t with the bit field value encoded.
   static uint32_t encode(T value) {
     ASSERT(is_valid(value));
     return static_cast<uint32_t>(value) << shift;
   }
 
   // Extracts the bit field from the value.
   static T decode(uint32_t value) {
     return static_cast<T>((value & mask()) >> shift);
   }
+
+  // Value for the field with all bits set.
+  static T max() {
+    return decode(mask());
+  }
 };
 
 
 // ----------------------------------------------------------------------------
 // Hash function.
 
 // Thomas Wang, Integer Hash Functions.
 // http://www.concentric.net/~Ttwang/tech/inthash.htm
 static inline uint32_t ComputeIntegerHash(uint32_t key) {
   uint32_t hash = key;
@@ skipping 80 matching lines @@
 
   // Returns the pointer to the start of the data in the vector.
   T* start() const { return start_; }
 
   // Access individual vector elements - checks bounds in debug mode.
   T& operator[](int index) const {
     ASSERT(0 <= index && index < length_);
     return start_[index];
   }
 
-  T& at(int i) const { return operator[](i); }
+  const T& at(int index) const { return operator[](index); }
 
   T& first() { return start_[0]; }
 
   T& last() { return start_[length_ - 1]; }
 
   // Returns a clone of this vector with a new backing store.
   Vector<T> Clone() const {
     T* result = NewArray<T>(length_);
     for (int i = 0; i < length_; i++) result[i] = start_[i];
     return Vector<T>(result, length_);
@@ skipping 40 matching lines @@
 
  protected:
   void set_start(T* start) { start_ = start; }
 
  private:
   T* start_;
   int length_;
 };
 
 
+// A pointer that can only be set once and doesn't allow NULL values.
+template<typename T>
+class SetOncePointer {
+ public:
+  SetOncePointer() : pointer_(NULL) { }
+
+  bool is_set() const { return pointer_ != NULL; }
+
+  T* get() const {
+    ASSERT(pointer_ != NULL);
+    return pointer_;
+  }
+
+  void set(T* value) {
+    ASSERT(pointer_ == NULL && value != NULL);
+    pointer_ = value;
+  }
+
+ private:
+  T* pointer_;
+};
+
+
 template <typename T, int kSize>
 class EmbeddedVector : public Vector<T> {
  public:
   EmbeddedVector() : Vector<T>(buffer_, kSize) { }
 
+  explicit EmbeddedVector(T initial_value) : Vector<T>(buffer_, kSize) {
+    for (int i = 0; i < kSize; ++i) {
+      buffer_[i] = initial_value;
+    }
+  }
+
   // When copying, make underlying Vector to reference our buffer.
   EmbeddedVector(const EmbeddedVector& rhs)
       : Vector<T>(rhs) {
     memcpy(buffer_, rhs.buffer_, sizeof(T) * kSize);
     set_start(buffer_);
   }
 
   EmbeddedVector& operator=(const EmbeddedVector& rhs) {
     if (this == &rhs) return *this;
     Vector<T>::operator=(rhs);
@@ skipping 315 matching lines @@
 }
 
 template <class Dest, class Source>
 inline Dest BitCast(Source* source) {
   return BitCast<Dest>(reinterpret_cast<uintptr_t>(source));
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_UTILS_H_