Made Isolate a mandatory parameter for everything Handle-related.

src/hydrogen-instructions.cc

 // 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 58 matching lines @@
 
 
 int HValue::LoopWeight() const {
   const int w = FLAG_loop_weight;
   static const int weights[] = { 1, w, w*w, w*w*w, w*w*w*w };
   return weights[Min(block()->LoopNestingDepth(),
                      static_cast<int>(ARRAY_SIZE(weights)-1))];
 }
 
 
+Isolate* HValue::isolate() const {
+  ASSERT(block() != NULL);
+  return block()->graph()->isolate();
+}
+
+
 void HValue::AssumeRepresentation(Representation r) {
   if (CheckFlag(kFlexibleRepresentation)) {
     ChangeRepresentation(r);
     // The representation of the value is dictated by type feedback and
     // will not be changed later.
     ClearFlag(kFlexibleRepresentation);
   }
 }
 
 
@@ skipping 246 matching lines @@
     case kNonPrimitive: return "non-primitive";
     case kJSArray: return "array";
     case kJSObject: return "object";
     case kUninitialized: return "uninitialized";
   }
   UNREACHABLE();
   return "Unreachable code";
 }
 
 
-HType HType::TypeFromValue(Handle<Object> value) {
+HType HType::TypeFromValue(Isolate* isolate, Handle<Object> value) {
   // Handle dereferencing is safe here: an object's type as checked below
   // never changes.
-  AllowHandleDereference allow_handle_deref;
+  AllowHandleDereference allow_handle_deref(isolate);
 
   HType result = HType::Tagged();
   if (value->IsSmi()) {
     result = HType::Smi();
   } else if (value->IsHeapNumber()) {
     result = HType::HeapNumber();
   } else if (value->IsString()) {
     result = HType::String();
   } else if (value->IsBoolean()) {
     result = HType::Boolean();
@@ skipping 933 matching lines @@
 
 HValue* HCheckInstanceType::Canonicalize() {
   if (check_ == IS_STRING &&
       !value()->type().IsUninitialized() &&
       value()->type().IsString()) {
     return NULL;
   }
 
   if (check_ == IS_SYMBOL && value()->IsConstant()) {
     // Dereferencing is safe here: a symbol cannot become a non-symbol.
-    AllowHandleDereference allow_handle_deref;
+    AllowHandleDereference allow_handle_deref(isolate());
     if (HConstant::cast(value())->handle()->IsSymbol()) return NULL;
   }
   return this;
 }
 
 
 void HCheckInstanceType::GetCheckInterval(InstanceType* first,
                                           InstanceType* last) {
   ASSERT(is_interval_check());
   switch (check_) {
@@ skipping 485 matching lines @@
   double roundtrip_value = static_cast<double>(static_cast<int32_t>(value));
   return BitCast<int64_t>(roundtrip_value) == BitCast<int64_t>(value);
 }
 
 
 HConstant::HConstant(Handle<Object> handle, Representation r)
     : handle_(handle),
       has_int32_value_(false),
       has_double_value_(false) {
   // Dereferencing here is safe: the value of a number object does not change.
-  AllowHandleDereference allow_handle_deref;
+  AllowHandleDereference allow_handle_deref(Isolate::Current());
   SetFlag(kUseGVN);
   if (handle_->IsNumber()) {
     double n = handle_->Number();
     has_int32_value_ = IsInteger32(n);
     int32_value_ = DoubleToInt32(n);
     double_value_ = n;
     has_double_value_ = true;
   }
   if (r.IsNone()) {
     if (has_int32_value_) {
@@ skipping 60 matching lines @@
 bool HConstant::ToBoolean() {
   // Converts the constant's boolean value according to
   // ECMAScript section 9.2 ToBoolean conversion.
   if (HasInteger32Value()) return Integer32Value() != 0;
   if (HasDoubleValue()) {
     double v = DoubleValue();
     return v != 0 && !isnan(v);
   }
   // Dereferencing is safe: singletons do not change and strings are
   // immutable.
-  AllowHandleDereference allow_handle_deref;
+  AllowHandleDereference allow_handle_deref(isolate());
   if (handle_->IsTrue()) return true;
   if (handle_->IsFalse()) return false;
   if (handle_->IsUndefined()) return false;
   if (handle_->IsNull()) return false;
   if (handle_->IsString() && String::cast(*handle_)->length() == 0) {
     return false;
   }
   return true;
 }
 
@@ skipping 667 matching lines @@
   }
   return result;
 }
 
 
 HType HConstant::CalculateInferredType() {
   if (has_int32_value_) {
     return Smi::IsValid(int32_value_) ? HType::Smi() : HType::HeapNumber();
   }
   if (has_double_value_) return HType::HeapNumber();
-  return HType::TypeFromValue(handle_);
+  return HType::TypeFromValue(isolate(), handle_);
 }
 
 
 HType HCompareGeneric::CalculateInferredType() {
   return HType::Boolean();
 }
 
 
 HType HInstanceOf::CalculateInferredType() {
   return HType::Boolean();
@@ skipping 238 matching lines @@
     }
   }
   return new(zone) HStringAdd(context, left, right);
 }
 
 
 HInstruction* HStringCharFromCode::New(
     Zone* zone, HValue* context, HValue* char_code) {
   if (FLAG_fold_constants && char_code->IsConstant()) {
     HConstant* c_code = HConstant::cast(char_code);
+    Isolate* isolate = Isolate::Current();
     if (c_code->HasNumberValue()) {
       if (isfinite(c_code->DoubleValue())) {
         uint32_t code = c_code->NumberValueAsInteger32() & 0xffff;
-        return new(zone) HConstant(LookupSingleCharacterStringFromCode(code),
+        return new(zone) HConstant(LookupSingleCharacterStringFromCode(isolate,
+                                                                       code),
                                    Representation::Tagged());
       }
-      return new(zone) HConstant(FACTORY->empty_string(),
+      return new(zone) HConstant(isolate->factory()->empty_string(),
                                  Representation::Tagged());
     }
   }
   return new(zone) HStringCharFromCode(context, char_code);
 }
 
 
 HInstruction* HStringLength::New(Zone* zone, HValue* string) {
   if (FLAG_fold_constants && string->IsConstant()) {
     HConstant* c_string = HConstant::cast(string);
@@ skipping 395 matching lines @@
 
 
 void HCheckFunction::Verify() {
   HInstruction::Verify();
   ASSERT(HasNoUses());
 }
 
 #endif
 
 } }  // namespace v8::internal