Merge isolates to bleeding_edge.

src/register-allocator.h

 // Copyright 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 51 matching lines @@
   };
 
   // Construct an invalid result.
   Result() { invalidate(); }
 
   // Construct a register Result.
   explicit Result(Register reg, TypeInfo info = TypeInfo::Unknown());
 
   // Construct a Result whose value is a compile-time constant.
   explicit Result(Handle<Object> value) {
+    ZoneObjectList* constant_list = Isolate::Current()->result_constant_list();
     TypeInfo info = TypeInfo::TypeFromValue(value);
     value_ = TypeField::encode(CONSTANT)
         | TypeInfoField::encode(info.ToInt())
         | IsUntaggedInt32Field::encode(false)
-        | DataField::encode(ConstantList()->length());
-    ConstantList()->Add(value);
+        | DataField::encode(constant_list->length());
+    constant_list->Add(value);
   }
 
   // The copy constructor and assignment operators could each create a new
   // register reference.
   inline Result(const Result& other);
 
   inline Result& operator=(const Result& other);
 
   inline ~Result();
 
-  // Static indirection table for handles to constants.  If a Result
-  // represents a constant, the data contains an index into this table
-  // of handles to the actual constants.
-  typedef ZoneList<Handle<Object> > ZoneObjectList;
-
-  static ZoneObjectList* ConstantList();
-
-  // Clear the constants indirection table.
-  static void ClearConstantList() {
-    ConstantList()->Clear();
-  }
-
   inline void Unuse();
 
   Type type() const { return TypeField::decode(value_); }
 
   void invalidate() { value_ = TypeField::encode(INVALID); }
 
   inline TypeInfo type_info() const;
   inline void set_type_info(TypeInfo info);
   inline bool is_number() const;
   inline bool is_smi() const;
@@ skipping 20 matching lines @@
   Register reg() const {
     ASSERT(is_register());
     uint32_t reg = DataField::decode(value_);
     Register result;
     result.code_ = reg;
     return result;
   }
 
   Handle<Object> handle() const {
     ASSERT(type() == CONSTANT);
-    return ConstantList()->at(DataField::decode(value_));
+    return Isolate::Current()->result_constant_list()->
+        at(DataField::decode(value_));
   }
 
   // Move this result to an arbitrary register.  The register is not
   // necessarily spilled from the frame or even singly-referenced outside
   // it.
   void ToRegister();
 
   // Move this result to a specified register.  The register is spilled from
   // the frame, and the register is singly-referenced (by this result)
   // outside the frame.
@@ skipping 160 matching lines @@
   }
 
  private:
   CodeGenerator* cgen_;
   RegisterFile registers_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_REGISTER_ALLOCATOR_H_