This is a little experiment to move Failure to a superclass above Object...

src/objects.cc

 // Copyright 2006-2009 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 37 matching lines @@
 namespace v8 {
 namespace internal {
 
 // Getters and setters are stored in a fixed array property.  These are
 // constants for their indices.
 const int kGetterIndex = 0;
 const int kSetterIndex = 1;
 
 
 MUST_USE_RESULT static Object* CreateJSValue(JSFunction* constructor,
+  Object* result;
+  { TryAllocation t = Heap::AllocateJSObject(constructor);
+    if (!t->ToObject(&result)) return t;
+  }
                                              Object* value) {
-  Object* result = Heap::AllocateJSObject(constructor);
-  if (result->IsFailure()) return result;
   JSValue::cast(result)->set_value(value);
   return result;
 }
 
 
 Object* Object::ToObject(Context* global_context) {
   if (IsNumber()) {
     return CreateJSValue(global_context->number_function(), this);
   } else if (IsBoolean()) {
     return CreateJSValue(global_context->boolean_function(), this);
@@ skipping 294 matching lines @@
 }
 
 
 Object* JSObject::SetNormalizedProperty(String* name,
                                         Object* value,
                                         PropertyDetails details) {
   ASSERT(!HasFastProperties());
   int entry = property_dictionary()->FindEntry(name);
   if (entry == StringDictionary::kNotFound) {
     Object* store_value = value;
+      { TryAllocation t = Heap::AllocateJSGlobalPropertyCell(value);
+        if (!t->ToObject(&store_value)) return t;
+      }
     if (IsGlobalObject()) {
-      store_value = Heap::AllocateJSGlobalPropertyCell(value);
-      if (store_value->IsFailure()) return store_value;
+    Object* dict;
+    { TryAllocation t = property_dictionary()->Add(name, store_value, details);
+      if (!t->ToObject(&dict)) return t;
     }
-    Object* dict = property_dictionary()->Add(name, store_value, details);
-    if (dict->IsFailure()) return dict;
+    }
     set_properties(StringDictionary::cast(dict));
     return value;
   }
   // Preserve enumeration index.
   details = PropertyDetails(details.attributes(),
                             details.type(),
                             property_dictionary()->DetailsAt(entry).index());
   if (IsGlobalObject()) {
     JSGlobalPropertyCell* cell =
         JSGlobalPropertyCell::cast(property_dictionary()->ValueAt(entry));
@@ skipping 13 matching lines @@
   int entry = dictionary->FindEntry(name);
   if (entry != StringDictionary::kNotFound) {
     // If we have a global object set the cell to the hole.
     if (IsGlobalObject()) {
       PropertyDetails details = dictionary->DetailsAt(entry);
       if (details.IsDontDelete()) {
         if (mode != FORCE_DELETION) return Heap::false_value();
         // When forced to delete global properties, we have to make a
         // map change to invalidate any ICs that think they can load
         // from the DontDelete cell without checking if it contains
+        Object* new_map;
+        { TryAllocation t = map()->CopyDropDescriptors();
+          if (!t->ToObject(&new_map)) return t;
+        }
         // the hole value.
-        Object* new_map = map()->CopyDropDescriptors();
-        if (new_map->IsFailure()) return new_map;
         set_map(Map::cast(new_map));
       }
       JSGlobalPropertyCell* cell =
           JSGlobalPropertyCell::cast(dictionary->ValueAt(entry));
       cell->set_value(Heap::the_hole_value());
       dictionary->DetailsAtPut(entry, details.AsDeleted());
     } else {
       return dictionary->DeleteProperty(entry, mode);
     }
   }
@@ skipping 208 matching lines @@
       if (cs->second()->length() == 0) {
         return cs->first();
       }
       // There's little point in putting the flat string in new space if the
       // cons string is in old space.  It can never get GCed until there is
       // an old space GC.
       PretenureFlag tenure = Heap::InNewSpace(this) ? pretenure : TENURED;
       int len = length();
       Object* object;
       String* result;
+        { TryAllocation t = Heap::AllocateRawAsciiString(len, tenure);
+          if (!t->ToObject(&object)) return t;
+        }
       if (IsAsciiRepresentation()) {
-        object = Heap::AllocateRawAsciiString(len, tenure);
-        if (object->IsFailure()) return object;
         result = String::cast(object);
         String* first = cs->first();
         int first_length = first->length();
         char* dest = SeqAsciiString::cast(result)->GetChars();
         WriteToFlat(first, dest, 0, first_length);
         String* second = cs->second();
         WriteToFlat(second,
                     dest + first_length,
                     0,
                     len - first_length);
+        { TryAllocation t = Heap::AllocateRawTwoByteString(len, tenure);
+          if (!t->ToObject(&object)) return t;
+        }
       } else {
-        object = Heap::AllocateRawTwoByteString(len, tenure);
-        if (object->IsFailure()) return object;
         result = String::cast(object);
         uc16* dest = SeqTwoByteString::cast(result)->GetChars();
         String* first = cs->first();
         int first_length = first->length();
         WriteToFlat(first, dest, 0, first_length);
         String* second = cs->second();
         WriteToFlat(second,
                     dest + first_length,
                     0,
                     len - first_length);
@@ skipping 516 matching lines @@
 }
 
 
 Object* JSObject::AddFastPropertyUsingMap(Map* new_map,
                                           String* name,
                                           Object* value) {
   int index = new_map->PropertyIndexFor(name);
   if (map()->unused_property_fields() == 0) {
     ASSERT(map()->unused_property_fields() == 0);
     int new_unused = new_map->unused_property_fields();
-    Object* values =
-        properties()->CopySize(properties()->length() + new_unused + 1);
-    if (values->IsFailure()) return values;
+    Object* values;
+    { TryAllocation t =
+          properties()->CopySize(properties()->length() + new_unused + 1);
+      if (!t->ToObject(&values)) return t;
+    }
     set_properties(FixedArray::cast(values));
   }
   set_map(new_map);
   return FastPropertyAtPut(index, value);
 }
 
 
 Object* JSObject::AddFastProperty(String* name,
                                   Object* value,
                                   PropertyAttributes attributes) {
   // Normalize the object if the name is an actual string (not the
   // hidden symbols) and is not a real identifier.
   StringInputBuffer buffer(name);
+    Object* obj;
+    { TryAllocation t = NormalizeProperties(CLEAR_INOBJECT_PROPERTIES, 0);
+      if (!t->ToObject(&obj)) return t;
+    }
   if (!Scanner::IsIdentifier(&buffer) && name != Heap::hidden_symbol()) {
-    Object* obj = NormalizeProperties(CLEAR_INOBJECT_PROPERTIES, 0);
-    if (obj->IsFailure()) return obj;
     return AddSlowProperty(name, value, attributes);
   }
 
   DescriptorArray* old_descriptors = map()->instance_descriptors();
   // Compute the new index for new field.
   int index = map()->NextFreePropertyIndex();
 
   // Allocate new instance descriptors with (name, index) added
   FieldDescriptor new_field(name, index, attributes);
-  Object* new_descriptors =
-      old_descriptors->CopyInsert(&new_field, REMOVE_TRANSITIONS);
-  if (new_descriptors->IsFailure()) return new_descriptors;
+  Object* new_descriptors;
+  { TryAllocation t =
+        old_descriptors->CopyInsert(&new_field, REMOVE_TRANSITIONS);
+    if (!t->ToObject(&new_descriptors)) return t;
+  }
 
   // Only allow map transition if the object's map is NOT equal to the
   // global object_function's map and there is not a transition for name.
   bool allow_map_transition =
         !old_descriptors->Contains(name) &&
         (Top::context()->global_context()->object_function()->map() != map());
 
   ASSERT(index < map()->inobject_properties() ||
          (index - map()->inobject_properties()) < properties()->length() ||
          map()->unused_property_fields() == 0);
+  Object* r;
+  { TryAllocation t = map()->CopyDropDescriptors();
+    if (!t->ToObject(&r)) return t;
+  }
   // Allocate a new map for the object.
-  Object* r = map()->CopyDropDescriptors();
-  if (r->IsFailure()) return r;
   Map* new_map = Map::cast(r);
   if (allow_map_transition) {
     // Allocate new instance descriptors for the old map with map transition.
+    Object* r;
+    { TryAllocation t = old_descriptors->CopyInsert(&d, KEEP_TRANSITIONS);
+      if (!t->ToObject(&r)) return t;
+    }
     MapTransitionDescriptor d(name, Map::cast(new_map), attributes);
-    Object* r = old_descriptors->CopyInsert(&d, KEEP_TRANSITIONS);
-    if (r->IsFailure()) return r;
     old_descriptors = DescriptorArray::cast(r);
   }
 
   if (map()->unused_property_fields() == 0) {
+      Object* obj;
+      { TryAllocation t = NormalizeProperties(CLEAR_INOBJECT_PROPERTIES, 0);
+        if (!t->ToObject(&obj)) return t;
+      }
     if (properties()->length() > MaxFastProperties()) {
-      Object* obj = NormalizeProperties(CLEAR_INOBJECT_PROPERTIES, 0);
-      if (obj->IsFailure()) return obj;
       return AddSlowProperty(name, value, attributes);
     }
     // Make room for the new value
-    Object* values =
-        properties()->CopySize(properties()->length() + kFieldsAdded);
-    if (values->IsFailure()) return values;
+    Object* values;
+    { TryAllocation t =
+          properties()->CopySize(properties()->length() + kFieldsAdded);
+      if (!t->ToObject(&values)) return t;
+    }
     set_properties(FixedArray::cast(values));
     new_map->set_unused_property_fields(kFieldsAdded - 1);
   } else {
     new_map->set_unused_property_fields(map()->unused_property_fields() - 1);
   }
   // We have now allocated all the necessary objects.
   // All the changes can be applied at once, so they are atomic.
   map()->set_instance_descriptors(old_descriptors);
   new_map->set_instance_descriptors(DescriptorArray::cast(new_descriptors));
   set_map(new_map);
   return FastPropertyAtPut(index, value);
 }
 
 
 Object* JSObject::AddConstantFunctionProperty(String* name,
                                               JSFunction* function,
                                               PropertyAttributes attributes) {
   ASSERT(!Heap::InNewSpace(function));
 
   // Allocate new instance descriptors with (name, function) added
   ConstantFunctionDescriptor d(name, function, attributes);
-  Object* new_descriptors =
-      map()->instance_descriptors()->CopyInsert(&d, REMOVE_TRANSITIONS);
-  if (new_descriptors->IsFailure()) return new_descriptors;
+  Object* new_descriptors;
+  { TryAllocation t =
+        map()->instance_descriptors()->CopyInsert(&d, REMOVE_TRANSITIONS);
+    if (!t->ToObject(&new_descriptors)) return t;
+  }
 
+  Object* new_map;
+  { TryAllocation t = map()->CopyDropDescriptors();
+    if (!t->ToObject(&new_map)) return t;
+  }
   // Allocate a new map for the object.
-  Object* new_map = map()->CopyDropDescriptors();
-  if (new_map->IsFailure()) return new_map;
 
   DescriptorArray* descriptors = DescriptorArray::cast(new_descriptors);
   Map::cast(new_map)->set_instance_descriptors(descriptors);
   Map* old_map = map();
   set_map(Map::cast(new_map));
 
   // If the old map is the global object map (from new Object()),
   // then transitions are not added to it, so we are done.
   if (old_map == Top::context()->global_context()->object_function()->map()) {
     return function;
@@ skipping 36 matching lines @@
     if (entry != StringDictionary::kNotFound) {
       store_value = dict->ValueAt(entry);
       JSGlobalPropertyCell::cast(store_value)->set_value(value);
       // Assign an enumeration index to the property and update
       // SetNextEnumerationIndex.
       int index = dict->NextEnumerationIndex();
       PropertyDetails details = PropertyDetails(attributes, NORMAL, index);
       dict->SetNextEnumerationIndex(index + 1);
       dict->SetEntry(entry, name, store_value, details);
       return value;
+    { TryAllocation t = Heap::AllocateJSGlobalPropertyCell(value);
+      if (!t->ToObject(&store_value)) return t;
     }
-    store_value = Heap::AllocateJSGlobalPropertyCell(value);
-    if (store_value->IsFailure()) return store_value;
+    }
     JSGlobalPropertyCell::cast(store_value)->set_value(value);
   }
+  Object* result;
+  { TryAllocation t = dict->Add(name, store_value, details);
+    if (!t->ToObject(&result)) return t;
+  }
   PropertyDetails details = PropertyDetails(attributes, NORMAL);
-  Object* result = dict->Add(name, store_value, details);
-  if (result->IsFailure()) return result;
   if (dict != result) set_properties(StringDictionary::cast(result));
   return value;
 }
 
 
 Object* JSObject::AddProperty(String* name,
                               Object* value,
                               PropertyAttributes attributes) {
   ASSERT(!IsJSGlobalProxy());
   if (!map()->is_extensible()) {
     Handle<Object> args[1] = {Handle<String>(name)};
     return Top::Throw(*Factory::NewTypeError("object_not_extensible",
                                                HandleVector(args, 1)));
   }
   if (HasFastProperties()) {
     // Ensure the descriptor array does not get too big.
     if (map()->instance_descriptors()->number_of_descriptors() <
         DescriptorArray::kMaxNumberOfDescriptors) {
       if (value->IsJSFunction() && !Heap::InNewSpace(value)) {
         return AddConstantFunctionProperty(name,
                                            JSFunction::cast(value),
                                            attributes);
       } else {
         return AddFastProperty(name, value, attributes);
       }
     } else {
       // Normalize the object to prevent very large instance descriptors.
+      Object* obj;
+      { TryAllocation t = NormalizeProperties(CLEAR_INOBJECT_PROPERTIES, 0);
+        if (!t->ToObject(&obj)) return t;
+      }
       // This eliminates unwanted N^2 allocation and lookup behavior.
-      Object* obj = NormalizeProperties(CLEAR_INOBJECT_PROPERTIES, 0);
-      if (obj->IsFailure()) return obj;
     }
   }
   return AddSlowProperty(name, value, attributes);
 }
 
 
 Object* JSObject::SetPropertyPostInterceptor(String* name,
                                              Object* value,
                                              PropertyAttributes attributes) {
   // Check local property, ignore interceptor.
@@ skipping 23 matching lines @@
 
   PropertyDetails new_details(attributes, NORMAL, new_enumeration_index);
   return SetNormalizedProperty(name, value, new_details);
 }
 
 
 Object* JSObject::ConvertDescriptorToFieldAndMapTransition(
     String* name,
     Object* new_value,
     PropertyAttributes attributes) {
+  Object* result;
+  { TryAllocation t = ConvertDescriptorToField(name, new_value, attributes);
+    if (!t->ToObject(&result)) return t;
+  }
   Map* old_map = map();
-  Object* result = ConvertDescriptorToField(name, new_value, attributes);
-  if (result->IsFailure()) return result;
   // If we get to this point we have succeeded - do not return failure
   // after this point.  Later stuff is optional.
   if (!HasFastProperties()) {
     return result;
   }
   // Do not add transitions to the map of "new Object()".
   if (map() == Top::context()->global_context()->object_function()->map()) {
     return result;
   }
 
   MapTransitionDescriptor transition(name,
                                      map(),
                                      attributes);
   Object* new_descriptors =
       old_map->instance_descriptors()->
           CopyInsert(&transition, KEEP_TRANSITIONS);
   if (new_descriptors->IsFailure()) return result;  // Yes, return _result_.
   old_map->set_instance_descriptors(DescriptorArray::cast(new_descriptors));
   return result;
 }
 
 
 Object* JSObject::ConvertDescriptorToField(String* name,
                                            Object* new_value,
                                            PropertyAttributes attributes) {
   if (map()->unused_property_fields() == 0 &&
+    Object* obj;
+    { TryAllocation t = NormalizeProperties(CLEAR_INOBJECT_PROPERTIES, 0);
+      if (!t->ToObject(&obj)) return t;
+    }
       properties()->length() > MaxFastProperties()) {
-    Object* obj = NormalizeProperties(CLEAR_INOBJECT_PROPERTIES, 0);
-    if (obj->IsFailure()) return obj;
     return ReplaceSlowProperty(name, new_value, attributes);
   }
 
   int index = map()->NextFreePropertyIndex();
   FieldDescriptor new_field(name, index, attributes);
   // Make a new DescriptorArray replacing an entry with FieldDescriptor.
-  Object* descriptors_unchecked = map()->instance_descriptors()->
-      CopyInsert(&new_field, REMOVE_TRANSITIONS);
-  if (descriptors_unchecked->IsFailure()) return descriptors_unchecked;
+  Object* descriptors_unchecked;
+  { TryAllocation t = map()->instance_descriptors()->
+        CopyInsert(&new_field, REMOVE_TRANSITIONS);
+    if (!t->ToObject(&descriptors_unchecked)) return t;
+  }
   DescriptorArray* new_descriptors =
       DescriptorArray::cast(descriptors_unchecked);
 
+  Object* new_map_unchecked;
+  { TryAllocation t = map()->CopyDropDescriptors();
+    if (!t->ToObject(&new_map_unchecked)) return t;
+  }
   // Make a new map for the object.
-  Object* new_map_unchecked = map()->CopyDropDescriptors();
-  if (new_map_unchecked->IsFailure()) return new_map_unchecked;
   Map* new_map = Map::cast(new_map_unchecked);
   new_map->set_instance_descriptors(new_descriptors);
 
   // Make new properties array if necessary.
   FixedArray* new_properties = 0;  // Will always be NULL or a valid pointer.
   int new_unused_property_fields = map()->unused_property_fields() - 1;
   if (map()->unused_property_fields() == 0) {
     new_unused_property_fields = kFieldsAdded - 1;
-    Object* new_properties_unchecked =
-        properties()->CopySize(properties()->length() + kFieldsAdded);
-    if (new_properties_unchecked->IsFailure()) return new_properties_unchecked;
+    Object* new_properties_unchecked;
+    { TryAllocation t =
+          properties()->CopySize(properties()->length() + kFieldsAdded);
+      if (!t->ToObject(&new_properties_unchecked)) return t;
+    }
     new_properties = FixedArray::cast(new_properties_unchecked);
   }
 
   // Update pointers to commit changes.
   // Object points to the new map.
   new_map->set_unused_property_fields(new_unused_property_fields);
   set_map(new_map);
   if (new_properties) {
     set_properties(FixedArray::cast(new_properties));
   }
@@ skipping 617 matching lines @@
       Object* fresh = fast->CopyNormalized(mode, SHARED_NORMALIZED_MAP);
       if (!fresh->IsFailure()) {
         ASSERT(memcmp(Map::cast(fresh)->address(),
                       Map::cast(result)->address(),
                       Map::kSize) == 0);
       }
     }
 #endif
     return result;
   }
+  { TryAllocation t = fast->CopyNormalized(mode, SHARED_NORMALIZED_MAP);
+    if (!t->ToObject(&result)) return t;
+  }
 
-  result = fast->CopyNormalized(mode, SHARED_NORMALIZED_MAP);
-  if (result->IsFailure()) return result;
   set(index, result);
   Counters::normalized_maps.Increment();
 
   return result;
 }
 
 
 void NormalizedMapCache::Clear() {
   int entries = length();
   for (int i = 0; i != entries; i++) {
@@ skipping 36 matching lines @@
     slow->bit_field() == fast->bit_field() &&
     (slow->bit_field2() & ~(1<<Map::kIsShared)) == fast->bit_field2();
 }
 
 
 Object* JSObject::UpdateMapCodeCache(String* name, Code* code) {
   if (map()->is_shared()) {
     // Fast case maps are never marked as shared.
     ASSERT(!HasFastProperties());
     // Replace the map with an identical copy that can be safely modified.
-    Object* obj = map()->CopyNormalized(KEEP_INOBJECT_PROPERTIES,
-                                        UNIQUE_NORMALIZED_MAP);
-    if (obj->IsFailure()) return obj;
+    Object* obj;
+    { TryAllocation t = map()->CopyNormalized(KEEP_INOBJECT_PROPERTIES,
+                                          UNIQUE_NORMALIZED_MAP);
+      if (!t->ToObject(&obj)) return t;
+    }
     Counters::normalized_maps.Increment();
 
     set_map(Map::cast(obj));
   }
   return map()->UpdateCodeCache(name, code);
 }
 
 
 Object* JSObject::NormalizeProperties(PropertyNormalizationMode mode,
                                       int expected_additional_properties) {
   if (!HasFastProperties()) return this;
 
   // The global object is always normalized.
   ASSERT(!IsGlobalObject());
 
   // Allocate new content.
   int property_count = map()->NumberOfDescribedProperties();
   if (expected_additional_properties > 0) {
     property_count += expected_additional_properties;
   } else {
     property_count += 2;  // Make space for two more properties.
   }
-  Object* obj =
-      StringDictionary::Allocate(property_count);
-  if (obj->IsFailure()) return obj;
+  Object* obj;
+  { TryAllocation t =
+        StringDictionary::Allocate(property_count);
+    if (!t->ToObject(&obj)) return t;
+  }
   StringDictionary* dictionary = StringDictionary::cast(obj);
 
   DescriptorArray* descs = map()->instance_descriptors();
   for (int i = 0; i < descs->number_of_descriptors(); i++) {
     PropertyDetails details = descs->GetDetails(i);
     switch (details.type()) {
       case CONSTANT_FUNCTION: {
         PropertyDetails d =
             PropertyDetails(details.attributes(), NORMAL, details.index());
+        Object* result;
+        { TryAllocation t = dictionary->Add(descs->GetKey(i), value, d);
+          if (!t->ToObject(&result)) return t;
+        }
         Object* value = descs->GetConstantFunction(i);
-        Object* result = dictionary->Add(descs->GetKey(i), value, d);
-        if (result->IsFailure()) return result;
         dictionary = StringDictionary::cast(result);
         break;
       }
       case FIELD: {
         PropertyDetails d =
             PropertyDetails(details.attributes(), NORMAL, details.index());
+        Object* result;
+        { TryAllocation t = dictionary->Add(descs->GetKey(i), value, d);
+          if (!t->ToObject(&result)) return t;
+        }
         Object* value = FastPropertyAt(descs->GetFieldIndex(i));
-        Object* result = dictionary->Add(descs->GetKey(i), value, d);
-        if (result->IsFailure()) return result;
         dictionary = StringDictionary::cast(result);
         break;
       }
       case CALLBACKS: {
         PropertyDetails d =
             PropertyDetails(details.attributes(), CALLBACKS, details.index());
+        Object* result;
+        { TryAllocation t = dictionary->Add(descs->GetKey(i), value, d);
+          if (!t->ToObject(&result)) return t;
+        }
         Object* value = descs->GetCallbacksObject(i);
-        Object* result = dictionary->Add(descs->GetKey(i), value, d);
-        if (result->IsFailure()) return result;
         dictionary = StringDictionary::cast(result);
         break;
       }
       case MAP_TRANSITION:
       case CONSTANT_TRANSITION:
       case NULL_DESCRIPTOR:
       case INTERCEPTOR:
         break;
       default:
         UNREACHABLE();
     }
   }
 
   // Copy the next enumeration index from instance descriptor.
   int index = map()->instance_descriptors()->NextEnumerationIndex();
   dictionary->SetNextEnumerationIndex(index);
 
-  obj = Top::context()->global_context()->
-      normalized_map_cache()->Get(this, mode);
-  if (obj->IsFailure()) return obj;
+  { TryAllocation t = Top::context()->global_context()->
+        normalized_map_cache()->Get(this, mode);
+    if (!t->ToObject(&obj)) return t;
+  }
   Map* new_map = Map::cast(obj);
 
   // We have now successfully allocated all the necessary objects.
   // Changes can now be made with the guarantee that all of them take effect.
 
   // Resize the object in the heap if necessary.
   int new_instance_size = new_map->instance_size();
   int instance_size_delta = map()->instance_size() - new_instance_size;
   ASSERT(instance_size_delta >= 0);
   Heap::CreateFillerObjectAt(this->address() + new_instance_size,
@@ skipping 20 matching lines @@
   ASSERT(!IsGlobalObject());
   return property_dictionary()->
       TransformPropertiesToFastFor(this, unused_property_fields);
 }
 
 
 Object* JSObject::NormalizeElements() {
   ASSERT(!HasPixelElements() && !HasExternalArrayElements());
   if (HasDictionaryElements()) return this;
   ASSERT(map()->has_fast_elements());
+  Object* obj;
+  { TryAllocation t = map()->GetSlowElementsMap();
+    if (!t->ToObject(&obj)) return t;
+  }
 
-  Object* obj = map()->GetSlowElementsMap();
-  if (obj->IsFailure()) return obj;
   Map* new_map = Map::cast(obj);
 
   // Get number of entries.
   FixedArray* array = FixedArray::cast(elements());
 
   // Compute the effective length.
   int length = IsJSArray() ?
                Smi::cast(JSArray::cast(this)->length())->value() :
+  { TryAllocation t = NumberDictionary::Allocate(length);
+    if (!t->ToObject(&obj)) return t;
+  }
                array->length();
-  obj = NumberDictionary::Allocate(length);
-  if (obj->IsFailure()) return obj;
   NumberDictionary* dictionary = NumberDictionary::cast(obj);
   // Copy entries.
   for (int i = 0; i < length; i++) {
     Object* value = array->get(i);
     if (!value->IsTheHole()) {
+      Object* result;
+      { TryAllocation t = dictionary->AddNumberEntry(i, array->get(i), details);
+        if (!t->ToObject(&result)) return t;
+      }
       PropertyDetails details = PropertyDetails(NONE, NORMAL);
-      Object* result = dictionary->AddNumberEntry(i, array->get(i), details);
-      if (result->IsFailure()) return result;
       dictionary = NumberDictionary::cast(result);
     }
   }
   // Switch to using the dictionary as the backing storage for
   // elements. Set the new map first to satify the elements type
   // assert in set_elements().
   set_map(new_map);
   set_elements(dictionary);
 
   Counters::elements_to_dictionary.Increment();
 
 #ifdef DEBUG
   if (FLAG_trace_normalization) {
     PrintF("Object elements have been normalized:\n");
     Print();
   }
 #endif
 
   return this;
 }
 
 
 Object* JSObject::DeletePropertyPostInterceptor(String* name, DeleteMode mode) {
   // Check local property, ignore interceptor.
   LookupResult result;
   LocalLookupRealNamedProperty(name, &result);
   if (!result.IsProperty()) return Heap::true_value();
 
+  Object* obj;
+  { TryAllocation t = NormalizeProperties(CLEAR_INOBJECT_PROPERTIES, 0);
+    if (!t->ToObject(&obj)) return t;
+  }
   // Normalize object if needed.
-  Object* obj = NormalizeProperties(CLEAR_INOBJECT_PROPERTIES, 0);
-  if (obj->IsFailure()) return obj;
 
   return DeleteNormalizedProperty(name, mode);
 }
 
 
 Object* JSObject::DeletePropertyWithInterceptor(String* name) {
   HandleScope scope;
   Handle<InterceptorInfo> interceptor(GetNamedInterceptor());
   Handle<String> name_handle(name);
   Handle<JSObject> this_handle(this);
@@ skipping 19 matching lines @@
       this_handle->DeletePropertyPostInterceptor(*name_handle, NORMAL_DELETION);
   RETURN_IF_SCHEDULED_EXCEPTION();
   return raw_result;
 }
 
 
 Object* JSObject::DeleteElementPostInterceptor(uint32_t index,
                                                DeleteMode mode) {
   ASSERT(!HasPixelElements() && !HasExternalArrayElements());
   switch (GetElementsKind()) {
+      Object* obj;
+      { TryAllocation t = EnsureWritableFastElements();
+        if (!t->ToObject(&obj)) return t;
+      }
     case FAST_ELEMENTS: {
-      Object* obj = EnsureWritableFastElements();
-      if (obj->IsFailure()) return obj;
       uint32_t length = IsJSArray() ?
       static_cast<uint32_t>(Smi::cast(JSArray::cast(this)->length())->value()) :
       static_cast<uint32_t>(FixedArray::cast(elements())->length());
       if (index < length) {
         FixedArray::cast(elements())->set_the_hole(index);
       }
       break;
     }
     case DICTIONARY_ELEMENTS: {
       NumberDictionary* dictionary = element_dictionary();
@@ skipping 59 matching lines @@
 
   if (HasIndexedInterceptor()) {
     // Skip interceptor if forcing deletion.
     if (mode == FORCE_DELETION) {
       return DeleteElementPostInterceptor(index, mode);
     }
     return DeleteElementWithInterceptor(index);
   }
 
   switch (GetElementsKind()) {
+      Object* obj;
+      { TryAllocation t = EnsureWritableFastElements();
+        if (!t->ToObject(&obj)) return t;
+      }
     case FAST_ELEMENTS: {
-      Object* obj = EnsureWritableFastElements();
-      if (obj->IsFailure()) return obj;
       uint32_t length = IsJSArray() ?
       static_cast<uint32_t>(Smi::cast(JSArray::cast(this)->length())->value()) :
       static_cast<uint32_t>(FixedArray::cast(elements())->length());
       if (index < length) {
         FixedArray::cast(elements())->set_the_hole(index);
       }
       break;
     }
     case PIXEL_ELEMENTS:
     case EXTERNAL_BYTE_ELEMENTS:
@@ skipping 52 matching lines @@
       return Heap::false_value();
     }
     // Check for interceptor.
     if (result.type() == INTERCEPTOR) {
       // Skip interceptor if forcing a deletion.
       if (mode == FORCE_DELETION) {
         return DeletePropertyPostInterceptor(name, mode);
       }
       return DeletePropertyWithInterceptor(name);
     }
+    Object* obj;
+    { TryAllocation t = NormalizeProperties(CLEAR_INOBJECT_PROPERTIES, 0);
+      if (!t->ToObject(&obj)) return t;
+    }
     // Normalize object if needed.
-    Object* obj = NormalizeProperties(CLEAR_INOBJECT_PROPERTIES, 0);
-    if (obj->IsFailure()) return obj;
     // Make sure the properties are normalized before removing the entry.
     return DeleteNormalizedProperty(name, mode);
   }
 }
 
 
 // Check whether this object references another object.
 bool JSObject::ReferencesObject(Object* obj) {
   AssertNoAllocation no_alloc;
 
@@ skipping 87 matching lines @@
     }
   }
 
   // No references to object.
   return false;
 }
 
 
 Object* JSObject::PreventExtensions() {
   // If there are fast elements we normalize.
+    Object* ok;
+    { TryAllocation t = NormalizeElements();
+      if (!t->ToObject(&ok)) return t;
+    }
   if (HasFastElements()) {
-    Object* ok = NormalizeElements();
-    if (ok->IsFailure()) return ok;
   }
   // Make sure that we never go back to fast case.
   element_dictionary()->set_requires_slow_elements();
 
   // Do a map transition, other objects with this map may still
+  Object* new_map;
+  { TryAllocation t = map()->CopyDropTransitions();
+    if (!t->ToObject(&new_map)) return t;
+  }
   // be extensible.
-  Object* new_map = map()->CopyDropTransitions();
-  if (new_map->IsFailure()) return new_map;
   Map::cast(new_map)->set_is_extensible(false);
   set_map(Map::cast(new_map));
   ASSERT(!map()->is_extensible());
   return new_map;
 }
 
 
 // Tests for the fast common case for property enumeration:
 // - This object and all prototypes has an enum cache (which means that it has
 //   no interceptors and needs no access checks).
@@ skipping 183 matching lines @@
         Object* obj = result.GetCallbackObject();
         // Need to preserve old getters/setters.
         if (obj->IsFixedArray()) {
           // Use set to update attributes.
           return SetPropertyCallback(name, obj, attributes);
         }
       }
     }
   }
 
+  Object* structure;
+  { TryAllocation t = Heap::AllocateFixedArray(2, TENURED);
+    if (!t->ToObject(&structure)) return t;
+  }
   // Allocate the fixed array to hold getter and setter.
-  Object* structure = Heap::AllocateFixedArray(2, TENURED);
-  if (structure->IsFailure()) return structure;
 
   if (is_element) {
     return SetElementCallback(index, structure, attributes);
   } else {
     return SetPropertyCallback(name, structure, attributes);
   }
 }
 
 
 bool JSObject::CanSetCallback(String* name) {
@@ skipping 18 matching lines @@
 
   return true;
 }
 
 
 Object* JSObject::SetElementCallback(uint32_t index,
                                      Object* structure,
                                      PropertyAttributes attributes) {
   PropertyDetails details = PropertyDetails(attributes, CALLBACKS);
 
+  Object* ok;
+  { TryAllocation t = NormalizeElements();
+    if (!t->ToObject(&ok)) return t;
+  }
   // Normalize elements to make this operation simple.
-  Object* ok = NormalizeElements();
-  if (ok->IsFailure()) return ok;
 
   // Update the dictionary with the new CALLBACKS property.
-  Object* dict =
-      element_dictionary()->Set(index, structure, details);
-  if (dict->IsFailure()) return dict;
+  Object* dict;
+  { TryAllocation t =
+        element_dictionary()->Set(index, structure, details);
+    if (!t->ToObject(&dict)) return t;
+  }
 
   NumberDictionary* elements = NumberDictionary::cast(dict);
   elements->set_requires_slow_elements();
   // Set the potential new dictionary on the object.
   set_elements(elements);
 
   return structure;
 }
 
 
 Object* JSObject::SetPropertyCallback(String* name,
                                       Object* structure,
                                       PropertyAttributes attributes) {
   PropertyDetails details = PropertyDetails(attributes, CALLBACKS);
 
   bool convert_back_to_fast = HasFastProperties() &&
       (map()->instance_descriptors()->number_of_descriptors()
           < DescriptorArray::kMaxNumberOfDescriptors);
 
+  Object* ok;
+  { TryAllocation t = NormalizeProperties(CLEAR_INOBJECT_PROPERTIES, 0);
+    if (!t->ToObject(&ok)) return t;
+  }
   // Normalize object to make this operation simple.
-  Object* ok = NormalizeProperties(CLEAR_INOBJECT_PROPERTIES, 0);
-  if (ok->IsFailure()) return ok;
 
   // For the global object allocate a new map to invalidate the global inline
   // caches which have a global property cell reference directly in the code.
+    Object* new_map;
+    { TryAllocation t = map()->CopyDropDescriptors();
+      if (!t->ToObject(&new_map)) return t;
+    }
   if (IsGlobalObject()) {
-    Object* new_map = map()->CopyDropDescriptors();
-    if (new_map->IsFailure()) return new_map;
     set_map(Map::cast(new_map));
   }
 
+  Object* result;
+  { TryAllocation t = SetNormalizedProperty(name, structure, details);
+    if (!t->ToObject(&result)) return t;
+  }
   // Update the dictionary with the new CALLBACKS property.
-  Object* result = SetNormalizedProperty(name, structure, details);
-  if (result->IsFailure()) return result;
 
+    { TryAllocation t = TransformToFastProperties(0);
+      if (!t->ToObject(&ok)) return t;
+    }
   if (convert_back_to_fast) {
-    ok = TransformToFastProperties(0);
-    if (ok->IsFailure()) return ok;
   }
   return result;
 }
 
 Object* JSObject::DefineAccessor(String* name, bool is_getter, JSFunction* fun,
                                  PropertyAttributes attributes) {
   // Check access rights if needed.
   if (IsAccessCheckNeeded() &&
       !Top::MayNamedAccess(this, name, v8::ACCESS_SET)) {
     Top::ReportFailedAccessCheck(this, v8::ACCESS_SET);
@@ skipping 62 matching lines @@
       case EXTERNAL_FLOAT_ELEMENTS:
         // Ignore getters and setters on pixel and external array
         // elements.
         return Heap::undefined_value();
       case DICTIONARY_ELEMENTS:
         break;
       default:
         UNREACHABLE();
         break;
     }
+    Object* ok;
+    { TryAllocation t =
+          SetElementCallback(index, info, info->property_attributes());
+      if (!t->ToObject(&ok)) return t;
+    }
 
-    Object* ok = SetElementCallback(index, info, info->property_attributes());
-    if (ok->IsFailure()) return ok;
   } else {
     // Lookup the name.
     LookupResult result;
     LocalLookup(name, &result);
     // ES5 forbids turning a property into an accessor if it's not
     // configurable (that is IsDontDelete in ES3 and v8), see 8.6.1 (Table 5).
     if (result.IsProperty() && (result.IsReadOnly() || result.IsDontDelete())) {
       return Heap::undefined_value();
+    Object* ok;
+    { TryAllocation t =
+          SetPropertyCallback(name, info, info->property_attributes());
+      if (!t->ToObject(&ok)) return t;
     }
-    Object* ok = SetPropertyCallback(name, info, info->property_attributes());
-    if (ok->IsFailure()) return ok;
+    }
   }
 
   return this;
 }
 
 
 Object* JSObject::LookupAccessor(String* name, bool is_getter) {
   // Make sure that the top context does not change when doing callbacks or
   // interceptor calls.
   AssertNoContextChange ncc;
@@ skipping 62 matching lines @@
         }
       }
     }
     return Heap::undefined_value();
   } else {
     return property_dictionary()->SlowReverseLookup(value);
   }
 }
 
 
+  Object* result;
+  { TryAllocation t = Heap::AllocateMap(instance_type(), instance_size());
+    if (!t->ToObject(&result)) return t;
+  }
 Object* Map::CopyDropDescriptors() {
-  Object* result = Heap::AllocateMap(instance_type(), instance_size());
-  if (result->IsFailure()) return result;
   Map::cast(result)->set_prototype(prototype());
   Map::cast(result)->set_constructor(constructor());
   // Don't copy descriptors, so map transitions always remain a forest.
   // If we retained the same descriptors we would have two maps
   // pointing to the same transition which is bad because the garbage
   // collector relies on being able to reverse pointers from transitions
   // to maps.  If properties need to be retained use CopyDropTransitions.
   Map::cast(result)->set_instance_descriptors(Heap::empty_descriptor_array());
   // Please note instance_type and instance_size are set when allocated.
   Map::cast(result)->set_inobject_properties(inobject_properties());
   Map::cast(result)->set_unused_property_fields(unused_property_fields());
 
   // If the map has pre-allocated properties always start out with a descriptor
   // array describing these properties.
   if (pre_allocated_property_fields() > 0) {
     ASSERT(constructor()->IsJSFunction());
     JSFunction* ctor = JSFunction::cast(constructor());
-    Object* descriptors =
-        ctor->initial_map()->instance_descriptors()->RemoveTransitions();
-    if (descriptors->IsFailure()) return descriptors;
+    Object* descriptors;
+    { TryAllocation t =
+          ctor->initial_map()->instance_descriptors()->RemoveTransitions();
+      if (!t->ToObject(&descriptors)) return t;
+    }
     Map::cast(result)->set_instance_descriptors(
         DescriptorArray::cast(descriptors));
     Map::cast(result)->set_pre_allocated_property_fields(
         pre_allocated_property_fields());
   }
   Map::cast(result)->set_bit_field(bit_field());
   Map::cast(result)->set_bit_field2(bit_field2());
   Map::cast(result)->set_is_shared(false);
   Map::cast(result)->ClearCodeCache();
   return result;
 }
 
 
 Object* Map::CopyNormalized(PropertyNormalizationMode mode,
                             NormalizedMapSharingMode sharing) {
   int new_instance_size = instance_size();
   if (mode == CLEAR_INOBJECT_PROPERTIES) {
     new_instance_size -= inobject_properties() * kPointerSize;
   }
+  Object* result;
+  { TryAllocation t = Heap::AllocateMap(instance_type(), new_instance_size);
+    if (!t->ToObject(&result)) return t;
+  }
 
-  Object* result = Heap::AllocateMap(instance_type(), new_instance_size);
-  if (result->IsFailure()) return result;
 
   if (mode != CLEAR_INOBJECT_PROPERTIES) {
     Map::cast(result)->set_inobject_properties(inobject_properties());
   }
 
   Map::cast(result)->set_prototype(prototype());
   Map::cast(result)->set_constructor(constructor());
 
   Map::cast(result)->set_bit_field(bit_field());
   Map::cast(result)->set_bit_field2(bit_field2());
 
   Map::cast(result)->set_is_shared(sharing == SHARED_NORMALIZED_MAP);
 
 #ifdef DEBUG
   if (Map::cast(result)->is_shared()) {
     Map::cast(result)->SharedMapVerify();
   }
 #endif
 
   return result;
 }
 
 
+  Object* new_map;
+  { TryAllocation t = CopyDropDescriptors();
+    if (!t->ToObject(&new_map)) return t;
+  }
 Object* Map::CopyDropTransitions() {
-  Object* new_map = CopyDropDescriptors();
-  if (new_map->IsFailure()) return new_map;
-  Object* descriptors = instance_descriptors()->RemoveTransitions();
-  if (descriptors->IsFailure()) return descriptors;
+  Object* descriptors;
+  { TryAllocation t = instance_descriptors()->RemoveTransitions();
+    if (!t->ToObject(&descriptors)) return t;
+  }
   cast(new_map)->set_instance_descriptors(DescriptorArray::cast(descriptors));
   return new_map;
 }
 
 
 Object* Map::UpdateCodeCache(String* name, Code* code) {
   // Allocate the code cache if not present.
+    Object* result;
+    { TryAllocation t = Heap::AllocateCodeCache();
+      if (!t->ToObject(&result)) return t;
+    }
   if (code_cache()->IsFixedArray()) {
-    Object* result = Heap::AllocateCodeCache();
-    if (result->IsFailure()) return result;
     set_code_cache(result);
   }
 
   // Update the code cache.
   return CodeCache::cast(code_cache())->Update(name, code);
 }
 
 
 Object* Map::FindInCodeCache(String* name, Code::Flags flags) {
   // Do a lookup if a code cache exists.
@@ skipping 65 matching lines @@
 
 Object* CodeCache::Update(String* name, Code* code) {
   ASSERT(code->ic_state() == MONOMORPHIC);
 
   // The number of monomorphic stubs for normal load/store/call IC's can grow to
   // a large number and therefore they need to go into a hash table. They are
   // used to load global properties from cells.
   if (code->type() == NORMAL) {
     // Make sure that a hash table is allocated for the normal load code cache.
     if (normal_type_cache()->IsUndefined()) {
-      Object* result =
-          CodeCacheHashTable::Allocate(CodeCacheHashTable::kInitialSize);
-      if (result->IsFailure()) return result;
+      Object* result;
+      { TryAllocation t =
+            CodeCacheHashTable::Allocate(CodeCacheHashTable::kInitialSize);
+        if (!t->ToObject(&result)) return t;
+      }
       set_normal_type_cache(result);
     }
     return UpdateNormalTypeCache(name, code);
   } else {
     ASSERT(default_cache()->IsFixedArray());
     return UpdateDefaultCache(name, code);
   }
 }
 
 
@@ skipping 35 matching lines @@
   if (deleted_index >= 0) {
     cache->set(deleted_index + kCodeCacheEntryNameOffset, name);
     cache->set(deleted_index + kCodeCacheEntryCodeOffset, code);
     return this;
   }
 
   // Extend the code cache with some new entries (at least one). Must be a
   // multiple of the entry size.
   int new_length = length + ((length >> 1)) + kCodeCacheEntrySize;
   new_length = new_length - new_length % kCodeCacheEntrySize;
+  Object* result;
+  { TryAllocation t = cache->CopySize(new_length);
+    if (!t->ToObject(&result)) return t;
+  }
   ASSERT((new_length % kCodeCacheEntrySize) == 0);
-  Object* result = cache->CopySize(new_length);
-  if (result->IsFailure()) return result;
 
   // Add the (name, code) pair to the new cache.
   cache = FixedArray::cast(result);
   cache->set(length + kCodeCacheEntryNameOffset, name);
   cache->set(length + kCodeCacheEntryCodeOffset, code);
   set_default_cache(cache);
   return this;
 }
 
 
 Object* CodeCache::UpdateNormalTypeCache(String* name, Code* code) {
   // Adding a new entry can cause a new cache to be allocated.
+  Object* new_cache;
+  { TryAllocation t = cache->Put(name, code);
+    if (!t->ToObject(&new_cache)) return t;
+  }
   CodeCacheHashTable* cache = CodeCacheHashTable::cast(normal_type_cache());
-  Object* new_cache = cache->Put(name, code);
-  if (new_cache->IsFailure()) return new_cache;
   set_normal_type_cache(new_cache);
   return this;
 }
 
 
 Object* CodeCache::Lookup(String* name, Code::Flags flags) {
   if (Code::ExtractTypeFromFlags(flags) == NORMAL) {
     return LookupNormalTypeCache(name, flags);
   } else {
     return LookupDefaultCache(name, flags);
@@ skipping 98 matching lines @@
   uint32_t Hash() { return NameFlagsHashHelper(name_, flags_); }
 
   uint32_t HashForObject(Object* obj) {
     FixedArray* pair = FixedArray::cast(obj);
     String* name = String::cast(pair->get(0));
     Code* code = Code::cast(pair->get(1));
     return NameFlagsHashHelper(name, code->flags());
   }
 
   Object* AsObject() {
+    Object* obj;
+    { TryAllocation t = Heap::AllocateFixedArray(2);
+      if (!t->ToObject(&obj)) return t;
+    }
     ASSERT(code_ != NULL);
-    Object* obj = Heap::AllocateFixedArray(2);
-    if (obj->IsFailure()) return obj;
     FixedArray* pair = FixedArray::cast(obj);
     pair->set(0, name_);
     pair->set(1, code_);
     return pair;
   }
 
  private:
   String* name_;
   Code::Flags flags_;
   Code* code_;
 };
 
 
 Object* CodeCacheHashTable::Lookup(String* name, Code::Flags flags) {
   CodeCacheHashTableKey key(name, flags);
   int entry = FindEntry(&key);
   if (entry == kNotFound) return Heap::undefined_value();
   return get(EntryToIndex(entry) + 1);
 }
 
 
 Object* CodeCacheHashTable::Put(String* name, Code* code) {
+  Object* obj;
+  { TryAllocation t = EnsureCapacity(1, &key);
+    if (!t->ToObject(&obj)) return t;
+  }
   CodeCacheHashTableKey key(name, code);
-  Object* obj = EnsureCapacity(1, &key);
-  if (obj->IsFailure()) return obj;
 
   // Don't use this, as the table might have grown.
   CodeCacheHashTable* cache = reinterpret_cast<CodeCacheHashTable*>(obj);
 
+  Object* k;
+  { TryAllocation t = key.AsObject();
+    if (!t->ToObject(&k)) return t;
+  }
   int entry = cache->FindInsertionEntry(key.Hash());
-  Object* k = key.AsObject();
-  if (k->IsFailure()) return k;
 
   cache->set(EntryToIndex(entry), k);
   cache->set(EntryToIndex(entry) + 1, code);
   cache->ElementAdded();
   return cache;
 }
 
 
 int CodeCacheHashTable::GetIndex(String* name, Code::Flags flags) {
   CodeCacheHashTableKey key(name, flags);
@@ skipping 26 matching lines @@
 
 Object* FixedArray::AddKeysFromJSArray(JSArray* array) {
   ASSERT(!array->HasPixelElements() && !array->HasExternalArrayElements());
   switch (array->GetElementsKind()) {
     case JSObject::FAST_ELEMENTS:
       return UnionOfKeys(FixedArray::cast(array->elements()));
     case JSObject::DICTIONARY_ELEMENTS: {
       NumberDictionary* dict = array->element_dictionary();
       int size = dict->NumberOfElements();
 
+      Object* object;
+      { TryAllocation t = Heap::AllocateFixedArray(size);
+        if (!t->ToObject(&object)) return t;
+      }
       // Allocate a temporary fixed array.
-      Object* object = Heap::AllocateFixedArray(size);
-      if (object->IsFailure()) return object;
       FixedArray* key_array = FixedArray::cast(object);
 
       int capacity = dict->Capacity();
       int pos = 0;
       // Copy the elements from the JSArray to the temporary fixed array.
       for (int i = 0; i < capacity; i++) {
         if (dict->IsKey(dict->KeyAt(i))) {
           key_array->set(pos++, dict->ValueAt(i));
         }
       }
@@ skipping 17 matching lines @@
 
   // Compute how many elements are not in this.
   int extra = 0;
   for (int y = 0; y < len1; y++) {
     Object* value = other->get(y);
     if (!value->IsTheHole() && !HasKey(this, value)) extra++;
   }
 
   if (extra == 0) return this;
 
+  Object* obj;
+  { TryAllocation t = Heap::AllocateFixedArray(len0 + extra);
+    if (!t->ToObject(&obj)) return t;
+  }
   // Allocate the result
-  Object* obj = Heap::AllocateFixedArray(len0 + extra);
-  if (obj->IsFailure()) return obj;
   // Fill in the content
   AssertNoAllocation no_gc;
   FixedArray* result = FixedArray::cast(obj);
   WriteBarrierMode mode = result->GetWriteBarrierMode(no_gc);
   for (int i = 0; i < len0; i++) {
     result->set(i, get(i), mode);
   }
   // Fill in the extra keys.
   int index = 0;
   for (int y = 0; y < len1; y++) {
     Object* value = other->get(y);
     if (!value->IsTheHole() && !HasKey(this, value)) {
       result->set(len0 + index, other->get(y), mode);
       index++;
     }
   }
   ASSERT(extra == index);
   return result;
 }
 
 
 Object* FixedArray::CopySize(int new_length) {
+  Object* obj;
+  { TryAllocation t = Heap::AllocateFixedArray(new_length);
+    if (!t->ToObject(&obj)) return t;
+  }
   if (new_length == 0) return Heap::empty_fixed_array();
-  Object* obj = Heap::AllocateFixedArray(new_length);
-  if (obj->IsFailure()) return obj;
   FixedArray* result = FixedArray::cast(obj);
   // Copy the content
   AssertNoAllocation no_gc;
   int len = length();
   if (new_length < len) len = new_length;
   result->set_map(map());
   WriteBarrierMode mode = result->GetWriteBarrierMode(no_gc);
   for (int i = 0; i < len; i++) {
     result->set(i, get(i), mode);
   }
@@ skipping 19 matching lines @@
   return true;
 }
 #endif
 
 
 Object* DescriptorArray::Allocate(int number_of_descriptors) {
   if (number_of_descriptors == 0) {
     return Heap::empty_descriptor_array();
   }
   // Allocate the array of keys.
-  Object* array =
-      Heap::AllocateFixedArray(ToKeyIndex(number_of_descriptors));
-  if (array->IsFailure()) return array;
+  Object* array;
+  { TryAllocation t =
+        Heap::AllocateFixedArray(ToKeyIndex(number_of_descriptors));
+    if (!t->ToObject(&array)) return t;
+  }
   // Do not use DescriptorArray::cast on incomplete object.
   FixedArray* result = FixedArray::cast(array);
 
+  { TryAllocation t = Heap::AllocateFixedArray(number_of_descriptors << 1);
+    if (!t->ToObject(&array)) return t;
+  }
   // Allocate the content array and set it in the descriptor array.
-  array = Heap::AllocateFixedArray(number_of_descriptors << 1);
-  if (array->IsFailure()) return array;
   result->set(kContentArrayIndex, array);
   result->set(kEnumerationIndexIndex,
               Smi::FromInt(PropertyDetails::kInitialIndex));
   return result;
 }
 
 
 void DescriptorArray::SetEnumCache(FixedArray* bridge_storage,
                                    FixedArray* new_cache) {
   ASSERT(bridge_storage->length() >= kEnumCacheBridgeLength);
@@ skipping 16 matching lines @@
                                     TransitionFlag transition_flag) {
   // Transitions are only kept when inserting another transition.
   // This precondition is not required by this function's implementation, but
   // is currently required by the semantics of maps, so we check it.
   // Conversely, we filter after replacing, so replacing a transition and
   // removing all other transitions is not supported.
   bool remove_transitions = transition_flag == REMOVE_TRANSITIONS;
   ASSERT(remove_transitions == !descriptor->GetDetails().IsTransition());
   ASSERT(descriptor->GetDetails().type() != NULL_DESCRIPTOR);
 
+  Object* result;
+  { TryAllocation t = descriptor->KeyToSymbol();
+    if (!t->ToObject(&result)) return t;
+  }
   // Ensure the key is a symbol.
-  Object* result = descriptor->KeyToSymbol();
-  if (result->IsFailure()) return result;
 
   int transitions = 0;
   int null_descriptors = 0;
   if (remove_transitions) {
     for (int i = 0; i < number_of_descriptors(); i++) {
       if (IsTransition(i)) transitions++;
       if (IsNullDescriptor(i)) null_descriptors++;
     }
   } else {
     for (int i = 0; i < number_of_descriptors(); i++) {
@@ skipping 18 matching lines @@
     if (t == CONSTANT_FUNCTION ||
         t == FIELD ||
         t == CALLBACKS ||
         t == INTERCEPTOR) {
       keep_enumeration_index = true;
     } else if (remove_transitions) {
      // Replaced descriptor has been counted as removed if it is
      // a transition that will be replaced.  Adjust count in this case.
       ++new_size;
     }
+  { TryAllocation t = Allocate(new_size);
+    if (!t->ToObject(&result)) return t;
   }
-  result = Allocate(new_size);
-  if (result->IsFailure()) return result;
+  }
   DescriptorArray* new_descriptors = DescriptorArray::cast(result);
   // Set the enumeration index in the descriptors and set the enumeration index
   // in the result.
   int enumeration_index = NextEnumerationIndex();
   if (!descriptor->GetDetails().IsTransition()) {
     if (keep_enumeration_index) {
       descriptor->SetEnumerationIndex(
           PropertyDetails(GetDetails(index)).index());
     } else {
       descriptor->SetEnumerationIndex(enumeration_index);
@@ skipping 38 matching lines @@
   // Remove all transitions and null descriptors. Return a copy of the array
   // with all transitions removed, or a Failure object if the new array could
   // not be allocated.
 
   // Compute the size of the map transition entries to be removed.
   int num_removed = 0;
   for (int i = 0; i < number_of_descriptors(); i++) {
     if (!IsProperty(i)) num_removed++;
   }
 
+  Object* result;
+  { TryAllocation t = Allocate(number_of_descriptors() - num_removed);
+    if (!t->ToObject(&result)) return t;
+  }
   // Allocate the new descriptor array.
-  Object* result = Allocate(number_of_descriptors() - num_removed);
-  if (result->IsFailure()) return result;
   DescriptorArray* new_descriptors = DescriptorArray::cast(result);
 
   // Copy the content.
   int next_descriptor = 0;
   for (int i = 0; i < number_of_descriptors(); i++) {
     if (IsProperty(i)) new_descriptors->CopyFrom(next_descriptor++, this, i);
   }
   ASSERT(next_descriptor == new_descriptors->number_of_descriptors());
 
   return new_descriptors;
@@ skipping 1331 matching lines @@
   ASSERT(should_have_prototype());
   Object* construct_prototype = value;
 
   // If the value is not a JSObject, store the value in the map's
   // constructor field so it can be accessed.  Also, set the prototype
   // used for constructing objects to the original object prototype.
   // See ECMA-262 13.2.2.
   if (!value->IsJSObject()) {
     // Copy the map so this does not affect unrelated functions.
     // Remove map transitions because they point to maps with a
+    Object* new_map;
+    { TryAllocation t = map()->CopyDropTransitions();
+      if (!t->ToObject(&new_map)) return t;
+    }
     // different prototype.
-    Object* new_map = map()->CopyDropTransitions();
-    if (new_map->IsFailure()) return new_map;
     set_map(Map::cast(new_map));
     map()->set_constructor(value);
     map()->set_non_instance_prototype(true);
     construct_prototype =
         Top::context()->global_context()->initial_object_prototype();
   } else {
     map()->set_non_instance_prototype(false);
   }
 
   return SetInstancePrototype(construct_prototype);
@@ skipping 12 matching lines @@
   shared()->set_instance_class_name(name);
   return this;
 }
 
 
 Context* JSFunction::GlobalContextFromLiterals(FixedArray* literals) {
   return Context::cast(literals->get(JSFunction::kLiteralGlobalContextIndex));
 }
 
 
+  Object* symbol;
+  { TryAllocation t = Heap::LookupAsciiSymbol(to_string);
+    if (!t->ToObject(&symbol)) return t;
+  }
 Object* Oddball::Initialize(const char* to_string, Object* to_number) {
-  Object* symbol = Heap::LookupAsciiSymbol(to_string);
-  if (symbol->IsFailure()) return symbol;
   set_to_string(String::cast(symbol));
   set_to_number(to_number);
   return this;
 }
 
 
 bool SharedFunctionInfo::HasSourceCode() {
   return !script()->IsUndefined() &&
          !reinterpret_cast<Script*>(script())->source()->IsUndefined();
 }
@@ skipping 464 matching lines @@
   for (RelocIterator it(this); !it.done(); it.next())
     it.rinfo()->Print();
   PrintF("\n");
 }
 #endif  // ENABLE_DISASSEMBLER
 
 
 Object* JSObject::SetFastElementsCapacityAndLength(int capacity, int length) {
   // We should never end in here with a pixel or external array.
   ASSERT(!HasPixelElements() && !HasExternalArrayElements());
+  Object* obj;
+  { TryAllocation t = Heap::AllocateFixedArrayWithHoles(capacity);
+    if (!t->ToObject(&obj)) return t;
+  }
 
-  Object* obj = Heap::AllocateFixedArrayWithHoles(capacity);
-  if (obj->IsFailure()) return obj;
   FixedArray* elems = FixedArray::cast(obj);
+  { TryAllocation t = map()->GetFastElementsMap();
+    if (!t->ToObject(&obj)) return t;
+  }
 
-  obj = map()->GetFastElementsMap();
-  if (obj->IsFailure()) return obj;
   Map* new_map = Map::cast(obj);
 
   AssertNoAllocation no_gc;
   WriteBarrierMode mode = elems->GetWriteBarrierMode(no_gc);
   switch (GetElementsKind()) {
     case FAST_ELEMENTS: {
       FixedArray* old_elements = FixedArray::cast(elements());
       uint32_t old_length = static_cast<uint32_t>(old_elements->length());
       // Fill out the new array with this content and array holes.
       for (uint32_t i = 0; i < old_length; i++) {
@@ skipping 31 matching lines @@
 Object* JSObject::SetSlowElements(Object* len) {
   // We should never end in here with a pixel or external array.
   ASSERT(!HasPixelElements() && !HasExternalArrayElements());
 
   uint32_t new_length = static_cast<uint32_t>(len->Number());
 
   switch (GetElementsKind()) {
     case FAST_ELEMENTS: {
       // Make sure we never try to shrink dense arrays into sparse arrays.
       ASSERT(static_cast<uint32_t>(FixedArray::cast(elements())->length()) <=
+      Object* obj;
+      { TryAllocation t = NormalizeElements();
+        if (!t->ToObject(&obj)) return t;
+      }
                                    new_length);
-      Object* obj = NormalizeElements();
-      if (obj->IsFailure()) return obj;
 
       // Update length for JSArrays.
       if (IsJSArray()) JSArray::cast(this)->set_length(len);
       break;
     }
     case DICTIONARY_ELEMENTS: {
       if (IsJSArray()) {
         uint32_t old_length =
             static_cast<uint32_t>(JSArray::cast(this)->length()->Number());
         element_dictionary()->RemoveNumberEntries(new_length, old_length),
         JSArray::cast(this)->set_length(len);
       }
       break;
     }
     default:
       UNREACHABLE();
       break;
   }
   return this;
 }
 
 
 Object* JSArray::Initialize(int capacity) {
   ASSERT(capacity >= 0);
   set_length(Smi::FromInt(0));
   FixedArray* new_elements;
   if (capacity == 0) {
     new_elements = Heap::empty_fixed_array();
+    Object* obj;
+    { TryAllocation t = Heap::AllocateFixedArrayWithHoles(capacity);
+      if (!t->ToObject(&obj)) return t;
+    }
   } else {
-    Object* obj = Heap::AllocateFixedArrayWithHoles(capacity);
-    if (obj->IsFailure()) return obj;
     new_elements = FixedArray::cast(obj);
   }
   set_elements(new_elements);
   return this;
 }
 
 
 void JSArray::Expand(int required_size) {
   Handle<JSArray> self(this);
   Handle<FixedArray> old_backing(FixedArray::cast(elements()));
@@ skipping 25 matching lines @@
   ASSERT(AllowsSetElementsLength());
 
   Object* smi_length = len->ToSmi();
   if (smi_length->IsSmi()) {
     const int value = Smi::cast(smi_length)->value();
     if (value < 0) return ArrayLengthRangeError();
     switch (GetElementsKind()) {
       case FAST_ELEMENTS: {
         int old_capacity = FixedArray::cast(elements())->length();
         if (value <= old_capacity) {
+            Object* obj;
+            { TryAllocation t = EnsureWritableFastElements();
+              if (!t->ToObject(&obj)) return t;
+            }
           if (IsJSArray()) {
-            Object* obj = EnsureWritableFastElements();
-            if (obj->IsFailure()) return obj;
             int old_length = FastD2I(JSArray::cast(this)->length()->Number());
             // NOTE: We may be able to optimize this by removing the
             // last part of the elements backing storage array and
             // setting the capacity to the new size.
             for (int i = value; i < old_length; i++) {
               FixedArray::cast(elements())->set_the_hole(i);
             }
             JSArray::cast(this)->set_length(Smi::cast(smi_length));
           }
           return this;
         }
         int min = NewElementsCapacity(old_capacity);
         int new_capacity = value > min ? value : min;
         if (new_capacity <= kMaxFastElementsLength ||
+          Object* obj;
+          { TryAllocation t =
+                SetFastElementsCapacityAndLength(new_capacity, value);
+            if (!t->ToObject(&obj)) return t;
+          }
             !ShouldConvertToSlowElements(new_capacity)) {
-          Object* obj = SetFastElementsCapacityAndLength(new_capacity, value);
-          if (obj->IsFailure()) return obj;
           return this;
         }
         break;
       }
       case DICTIONARY_ELEMENTS: {
         if (IsJSArray()) {
           if (value == 0) {
             // If the length of a slow array is reset to zero, we clear
             // the array and flush backing storage. This has the added
+            Object* obj;
+            { TryAllocation t = ResetElements();
+              if (!t->ToObject(&obj)) return t;
+            }
             // benefit that the array returns to fast mode.
-            Object* obj = ResetElements();
-            if (obj->IsFailure()) return obj;
           } else {
             // Remove deleted elements.
             uint32_t old_length =
             static_cast<uint32_t>(JSArray::cast(this)->length()->Number());
             element_dictionary()->RemoveNumberEntries(value, old_length);
           }
           JSArray::cast(this)->set_length(Smi::cast(smi_length));
         }
         return this;
       }
       default:
         UNREACHABLE();
         break;
     }
   }
 
   // General slow case.
   if (len->IsNumber()) {
     uint32_t length;
     if (len->ToArrayIndex(&length)) {
       return SetSlowElements(len);
     } else {
       return ArrayLengthRangeError();
     }
   }
 
   // len is not a number so make the array size one and
+  Object* obj;
+  { TryAllocation t = Heap::AllocateFixedArray(1);
+    if (!t->ToObject(&obj)) return t;
+  }
   // set only element to len.
-  Object* obj = Heap::AllocateFixedArray(1);
-  if (obj->IsFailure()) return obj;
   FixedArray::cast(obj)->set(0, len);
   if (IsJSArray()) JSArray::cast(this)->set_length(Smi::FromInt(1));
   set_elements(FixedArray::cast(obj));
   return this;
 }
 
 
 Object* JSObject::SetPrototype(Object* value,
                                bool skip_hidden_prototypes) {
   // Silently ignore the change if value is not a JSObject or null.
@@ skipping 19 matching lines @@
     // Find the first object in the chain whose prototype object is not
     // hidden and set the new prototype on that object.
     Object* current_proto = real_receiver->GetPrototype();
     while (current_proto->IsJSObject() &&
           JSObject::cast(current_proto)->map()->is_hidden_prototype()) {
       real_receiver = JSObject::cast(current_proto);
       current_proto = current_proto->GetPrototype();
     }
   }
 
+  Object* new_map;
+  { TryAllocation t = real_receiver->map()->CopyDropTransitions();
+    if (!t->ToObject(&new_map)) return t;
+  }
   // Set the new prototype of the object.
-  Object* new_map = real_receiver->map()->CopyDropTransitions();
-  if (new_map->IsFailure()) return new_map;
   Map::cast(new_map)->set_prototype(value);
   real_receiver->set_map(Map::cast(new_map));
 
   Heap::ClearInstanceofCache();
 
   return value;
 }
 
 
 bool JSObject::HasElementPostInterceptor(JSObject* receiver, uint32_t index) {
@@ skipping 349 matching lines @@
   UNREACHABLE();
   return NULL;
 }
 
 
 // Adding n elements in fast case is O(n*n).
 // Note: revisit design to have dual undefined values to capture absent
 // elements.
 Object* JSObject::SetFastElement(uint32_t index, Object* value) {
   ASSERT(HasFastElements());
+  Object* elms_obj;
+  { TryAllocation t = EnsureWritableFastElements();
+    if (!t->ToObject(&elms_obj)) return t;
+  }
 
-  Object* elms_obj = EnsureWritableFastElements();
-  if (elms_obj->IsFailure()) return elms_obj;
   FixedArray* elms = FixedArray::cast(elms_obj);
   uint32_t elms_length = static_cast<uint32_t>(elms->length());
 
   if (!IsJSArray() && (index >= elms_length || elms->get(index)->IsTheHole())) {
     if (SetElementWithCallbackSetterInPrototypes(index, value)) {
       return value;
     }
   }
 
   // Check whether there is extra space in fixed array..
   if (index < elms_length) {
     elms->set(index, value);
     if (IsJSArray()) {
       // Update the length of the array if needed.
       uint32_t array_length = 0;
       CHECK(JSArray::cast(this)->length()->ToArrayIndex(&array_length));
       if (index >= array_length) {
         JSArray::cast(this)->set_length(Smi::FromInt(index + 1));
       }
     }
     return value;
   }
 
   // Allow gap in fast case.
   if ((index - elms_length) < kMaxGap) {
     // Try allocating extra space.
     int new_capacity = NewElementsCapacity(index+1);
     if (new_capacity <= kMaxFastElementsLength ||
         !ShouldConvertToSlowElements(new_capacity)) {
+      Object* obj;
+      { TryAllocation t =
+            SetFastElementsCapacityAndLength(new_capacity, index + 1);
+        if (!t->ToObject(&obj)) return t;
+      }
       ASSERT(static_cast<uint32_t>(new_capacity) > index);
-      Object* obj = SetFastElementsCapacityAndLength(new_capacity, index + 1);
-      if (obj->IsFailure()) return obj;
       FixedArray::cast(elements())->set(index, value);
       return value;
     }
   }
 
+  Object* obj;
+  { TryAllocation t = NormalizeElements();
+    if (!t->ToObject(&obj)) return t;
+  }
   // Otherwise default to slow case.
-  Object* obj = NormalizeElements();
-  if (obj->IsFailure()) return obj;
   ASSERT(HasDictionaryElements());
   return SetElement(index, value);
 }
 
 
 Object* JSObject::SetElement(uint32_t index, Object* value) {
   // Check access rights if needed.
   if (IsAccessCheckNeeded() &&
       !Top::MayIndexedAccess(this, index, v8::ACCESS_SET)) {
     HandleScope scope;
@@ skipping 81 matching lines @@
           }
         }
         // When we set the is_extensible flag to false we always force
         // the element into dictionary mode (and force them to stay there).
         if (!map()->is_extensible()) {
           Handle<Object> number(Heap::NumberFromUint32(index));
           Handle<String> index_string(Factory::NumberToString(number));
           Handle<Object> args[1] = { index_string };
           return Top::Throw(*Factory::NewTypeError("object_not_extensible",
                                                    HandleVector(args, 1)));
+        Object* result;
+        { TryAllocation t = dictionary->AtNumberPut(index, value);
+          if (!t->ToObject(&result)) return t;
         }
-        Object* result = dictionary->AtNumberPut(index, value);
-        if (result->IsFailure()) return result;
+        }
         if (elms != FixedArray::cast(result)) {
           set_elements(FixedArray::cast(result));
         }
       }
 
       // Update the array length if this JSObject is an array.
       if (IsJSArray()) {
         JSArray* array = JSArray::cast(this);
-        Object* return_value = array->JSArrayUpdateLengthFromIndex(index,
-                                                                   value);
-        if (return_value->IsFailure()) return return_value;
+        Object* return_value;
+        { TryAllocation t = array->JSArrayUpdateLengthFromIndex(index,
+                                                                     value);
+          if (!t->ToObject(&return_value)) return t;
+        }
       }
 
       // Attempt to put this object back in fast case.
       if (ShouldConvertToFastElements()) {
         uint32_t new_length = 0;
         if (IsJSArray()) {
           CHECK(JSArray::cast(this)->length()->ToArrayIndex(&new_length));
         } else {
           new_length = NumberDictionary::cast(elements())->max_number_key() + 1;
+        Object* obj;
+        { TryAllocation t =
+              SetFastElementsCapacityAndLength(new_length, new_length);
+          if (!t->ToObject(&obj)) return t;
         }
-        Object* obj = SetFastElementsCapacityAndLength(new_length, new_length);
-        if (obj->IsFailure()) return obj;
+        }
 #ifdef DEBUG
         if (FLAG_trace_normalization) {
           PrintF("Object elements are fast case again:\n");
           Print();
         }
 #endif
       }
 
       return value;
     }
     default:
       UNREACHABLE();
       break;
   }
   // All possible cases have been handled above. Add a return to avoid the
   // complaints from the compiler.
   UNREACHABLE();
   return Heap::null_value();
 }
 
 
 Object* JSArray::JSArrayUpdateLengthFromIndex(uint32_t index, Object* value) {
   uint32_t old_len = 0;
   CHECK(length()->ToArrayIndex(&old_len));
   // Check to see if we need to update the length. For now, we make
   // sure that the length stays within 32-bits (unsigned).
   if (index >= old_len && index != 0xffffffff) {
-    Object* len =
-        Heap::NumberFromDouble(static_cast<double>(index) + 1);
-    if (len->IsFailure()) return len;
+    Object* len;
+    { TryAllocation t =
+          Heap::NumberFromDouble(static_cast<double>(index) + 1);
+      if (!t->ToObject(&len)) return t;
+    }
     set_length(len);
   }
   return value;
 }
 
 
 Object* JSObject::GetElementPostInterceptor(JSObject* receiver,
                                             uint32_t index) {
   // Get element works for both JSObject and JSArray since
   // JSArray::length cannot change.
@@ skipping 839 matching lines @@
     return StringSharedHashHelper(source_, shared_);
   }
 
   uint32_t HashForObject(Object* obj) {
     FixedArray* pair = FixedArray::cast(obj);
     SharedFunctionInfo* shared = SharedFunctionInfo::cast(pair->get(0));
     String* source = String::cast(pair->get(1));
     return StringSharedHashHelper(source, shared);
   }
 
+    Object* obj;
+    { TryAllocation t = Heap::AllocateFixedArray(2);
+      if (!t->ToObject(&obj)) return t;
+    }
   Object* AsObject() {
-    Object* obj = Heap::AllocateFixedArray(2);
-    if (obj->IsFailure()) return obj;
     FixedArray* pair = FixedArray::cast(obj);
     pair->set(0, shared_);
     pair->set(1, source_);
     return pair;
   }
 
  private:
   String* source_;
   SharedFunctionInfo* shared_;
 };
@@ skipping 216 matching lines @@
   // Return if:
   //   50% is still free after adding n elements and
   //   at most 50% of the free elements are deleted elements.
   if (nod <= (capacity - nof) >> 1) {
     int needed_free = nof >> 1;
     if (nof + needed_free <= capacity) return this;
   }
 
   const int kMinCapacityForPretenure = 256;
   bool pretenure =
+  Object* obj;
+  { TryAllocation t = Allocate(nof * 2, pretenure ? TENURED : NOT_TENURED);
+    if (!t->ToObject(&obj)) return t;
+  }
       (capacity > kMinCapacityForPretenure) && !Heap::InNewSpace(this);
-  Object* obj = Allocate(nof * 2, pretenure ? TENURED : NOT_TENURED);
-  if (obj->IsFailure()) return obj;
 
   AssertNoAllocation no_gc;
   HashTable* table = HashTable::cast(obj);
   WriteBarrierMode mode = table->GetWriteBarrierMode(no_gc);
 
   // Copy prefix to new array.
   for (int i = kPrefixStartIndex;
        i < kPrefixStartIndex + Shape::kPrefixSize;
        i++) {
     table->set(i, get(i), mode);
@@ skipping 113 matching lines @@
 // Collates undefined and unexisting elements below limit from position
 // zero of the elements. The object stays in Dictionary mode.
 Object* JSObject::PrepareSlowElementsForSort(uint32_t limit) {
   ASSERT(HasDictionaryElements());
   // Must stay in dictionary mode, either because of requires_slow_elements,
   // or because we are not going to sort (and therefore compact) all of the
   // elements.
   NumberDictionary* dict = element_dictionary();
   HeapNumber* result_double = NULL;
   if (limit > static_cast<uint32_t>(Smi::kMaxValue)) {
+    Object* new_double;
+    { TryAllocation t = Heap::AllocateHeapNumber(0.0);
+      if (!t->ToObject(&new_double)) return t;
+    }
     // Allocate space for result before we start mutating the object.
-    Object* new_double = Heap::AllocateHeapNumber(0.0);
-    if (new_double->IsFailure()) return new_double;
     result_double = HeapNumber::cast(new_double);
   }
+  Object* obj;
+  { TryAllocation t = NumberDictionary::Allocate(dict->NumberOfElements());
+    if (!t->ToObject(&obj)) return t;
+  }
 
-  Object* obj = NumberDictionary::Allocate(dict->NumberOfElements());
-  if (obj->IsFailure()) return obj;
   NumberDictionary* new_dict = NumberDictionary::cast(obj);
 
   AssertNoAllocation no_alloc;
 
   uint32_t pos = 0;
   uint32_t undefs = 0;
   int capacity = dict->Capacity();
   for (int i = 0; i < capacity; i++) {
     Object* k = dict->KeyAt(i);
     if (dict->IsKey(k)) {
@@ skipping 50 matching lines @@
 
   if (HasDictionaryElements()) {
     // Convert to fast elements containing only the existing properties.
     // Ordering is irrelevant, since we are going to sort anyway.
     NumberDictionary* dict = element_dictionary();
     if (IsJSArray() || dict->requires_slow_elements() ||
         dict->max_number_key() >= limit) {
       return PrepareSlowElementsForSort(limit);
     }
     // Convert to fast elements.
+    Object* obj;
+    { TryAllocation t = map()->GetFastElementsMap();
+      if (!t->ToObject(&obj)) return t;
+    }
 
-    Object* obj = map()->GetFastElementsMap();
-    if (obj->IsFailure()) return obj;
     Map* new_map = Map::cast(obj);
 
     PretenureFlag tenure = Heap::InNewSpace(this) ? NOT_TENURED: TENURED;
-    Object* new_array =
-        Heap::AllocateFixedArray(dict->NumberOfElements(), tenure);
-    if (new_array->IsFailure()) return new_array;
+    Object* new_array;
+    { TryAllocation t =
+          Heap::AllocateFixedArray(dict->NumberOfElements(), tenure);
+      if (!t->ToObject(&new_array)) return t;
+    }
     FixedArray* fast_elements = FixedArray::cast(new_array);
     dict->CopyValuesTo(fast_elements);
 
     set_map(new_map);
     set_elements(fast_elements);
+    Object* obj;
+    { TryAllocation t = EnsureWritableFastElements();
+      if (!t->ToObject(&obj)) return t;
+    }
   } else {
-    Object* obj = EnsureWritableFastElements();
-    if (obj->IsFailure()) return obj;
   }
   ASSERT(HasFastElements());
 
   // Collect holes at the end, undefined before that and the rest at the
   // start, and return the number of non-hole, non-undefined values.
 
   FixedArray* elements = FixedArray::cast(this->elements());
   uint32_t elements_length = static_cast<uint32_t>(elements->length());
   if (limit > elements_length) {
     limit = elements_length ;
   }
   if (limit == 0) {
     return Smi::FromInt(0);
   }
 
   HeapNumber* result_double = NULL;
   if (limit > static_cast<uint32_t>(Smi::kMaxValue)) {
     // Pessimistically allocate space for return value before
+    Object* new_double;
+    { TryAllocation t = Heap::AllocateHeapNumber(0.0);
+      if (!t->ToObject(&new_double)) return t;
+    }
     // we start mutating the array.
-    Object* new_double = Heap::AllocateHeapNumber(0.0);
-    if (new_double->IsFailure()) return new_double;
     result_double = HeapNumber::cast(new_double);
   }
 
   AssertNoAllocation no_alloc;
 
   // Split elements into defined, undefined and the_hole, in that order.
   // Only count locations for undefined and the hole, and fill them afterwards.
   WriteBarrierMode write_barrier = elements->GetWriteBarrierMode(no_alloc);
   unsigned int undefs = limit;
   unsigned int holes = limit;
@@ skipping 174 matching lines @@
   ASSERT(!HasFastProperties());
   Object* value = property_dictionary()->ValueAt(result->GetDictionaryEntry());
   ASSERT(value->IsJSGlobalPropertyCell());
   return value;
 }
 
 
 Object* GlobalObject::EnsurePropertyCell(String* name) {
   ASSERT(!HasFastProperties());
   int entry = property_dictionary()->FindEntry(name);
+    Object* cell;
+    { TryAllocation t =
+          Heap::AllocateJSGlobalPropertyCell(Heap::the_hole_value());
+      if (!t->ToObject(&cell)) return t;
+    }
   if (entry == StringDictionary::kNotFound) {
-    Object* cell = Heap::AllocateJSGlobalPropertyCell(Heap::the_hole_value());
-    if (cell->IsFailure()) return cell;
     PropertyDetails details(NONE, NORMAL);
+    Object* dictionary;
+    { TryAllocation t = property_dictionary()->Add(name, cell, details);
+      if (!t->ToObject(&dictionary)) return t;
+    }
     details = details.AsDeleted();
-    Object* dictionary = property_dictionary()->Add(name, cell, details);
-    if (dictionary->IsFailure()) return dictionary;
     set_properties(StringDictionary::cast(dictionary));
     return cell;
   } else {
     Object* value = property_dictionary()->ValueAt(entry);
     ASSERT(value->IsJSGlobalPropertyCell());
     return value;
   }
 }
 
 
@@ skipping 102 matching lines @@
 
 Object* SymbolTable::LookupKey(HashTableKey* key, Object** s) {
   int entry = FindEntry(key);
 
   // Symbol already in table.
   if (entry != kNotFound) {
     *s = KeyAt(entry);
     return this;
   }
 
+  Object* obj;
+  { TryAllocation t = EnsureCapacity(1, key);
+    if (!t->ToObject(&obj)) return t;
+  }
   // Adding new symbol. Grow table if needed.
-  Object* obj = EnsureCapacity(1, key);
-  if (obj->IsFailure()) return obj;
 
+  Object* symbol;
+  { TryAllocation t = key->AsObject();
+    if (!t->ToObject(&symbol)) return t;
+  }
   // Create symbol object.
-  Object* symbol = key->AsObject();
-  if (symbol->IsFailure()) return symbol;
 
   // If the symbol table grew as part of EnsureCapacity, obj is not
   // the current symbol table and therefore we cannot use
   // SymbolTable::cast here.
   SymbolTable* table = reinterpret_cast<SymbolTable*>(obj);
 
   // Add the new symbol and return it along with the symbol table.
   entry = table->FindInsertionEntry(key->Hash());
   table->set(EntryToIndex(entry), symbol);
   table->ElementAdded();
@@ skipping 21 matching lines @@
 Object* CompilationCacheTable::LookupRegExp(String* src,
                                             JSRegExp::Flags flags) {
   RegExpKey key(src, flags);
   int entry = FindEntry(&key);
   if (entry == kNotFound) return Heap::undefined_value();
   return get(EntryToIndex(entry) + 1);
 }
 
 
 Object* CompilationCacheTable::Put(String* src, Object* value) {
+  Object* obj;
+  { TryAllocation t = EnsureCapacity(1, &key);
+    if (!t->ToObject(&obj)) return t;
+  }
   StringKey key(src);
-  Object* obj = EnsureCapacity(1, &key);
-  if (obj->IsFailure()) return obj;
 
   CompilationCacheTable* cache =
       reinterpret_cast<CompilationCacheTable*>(obj);
   int entry = cache->FindInsertionEntry(key.Hash());
   cache->set(EntryToIndex(entry), src);
   cache->set(EntryToIndex(entry) + 1, value);
   cache->ElementAdded();
   return cache;
 }
 
 
 Object* CompilationCacheTable::PutEval(String* src,
                                        Context* context,
                                        Object* value) {
+  Object* obj;
+  { TryAllocation t = EnsureCapacity(1, &key);
+    if (!t->ToObject(&obj)) return t;
+  }
   StringSharedKey key(src, context->closure()->shared());
-  Object* obj = EnsureCapacity(1, &key);
-  if (obj->IsFailure()) return obj;
 
   CompilationCacheTable* cache =
       reinterpret_cast<CompilationCacheTable*>(obj);
   int entry = cache->FindInsertionEntry(key.Hash());
+  Object* k;
+  { TryAllocation t = key.AsObject();
+    if (!t->ToObject(&k)) return t;
+  }
 
-  Object* k = key.AsObject();
-  if (k->IsFailure()) return k;
 
   cache->set(EntryToIndex(entry), k);
   cache->set(EntryToIndex(entry) + 1, value);
   cache->ElementAdded();
   return cache;
 }
 
 
 Object* CompilationCacheTable::PutRegExp(String* src,
                                          JSRegExp::Flags flags,
                                          FixedArray* value) {
+  Object* obj;
+  { TryAllocation t = EnsureCapacity(1, &key);
+    if (!t->ToObject(&obj)) return t;
+  }
   RegExpKey key(src, flags);
-  Object* obj = EnsureCapacity(1, &key);
-  if (obj->IsFailure()) return obj;
 
   CompilationCacheTable* cache =
       reinterpret_cast<CompilationCacheTable*>(obj);
   int entry = cache->FindInsertionEntry(key.Hash());
   // We store the value in the key slot, and compare the search key
   // to the stored value with a custon IsMatch function during lookups.
   cache->set(EntryToIndex(entry), value);
   cache->set(EntryToIndex(entry) + 1, value);
   cache->ElementAdded();
   return cache;
@@ skipping 36 matching lines @@
 
 Object* MapCache::Lookup(FixedArray* array) {
   SymbolsKey key(array);
   int entry = FindEntry(&key);
   if (entry == kNotFound) return Heap::undefined_value();
   return get(EntryToIndex(entry) + 1);
 }
 
 
 Object* MapCache::Put(FixedArray* array, Map* value) {
+  Object* obj;
+  { TryAllocation t = EnsureCapacity(1, &key);
+    if (!t->ToObject(&obj)) return t;
+  }
   SymbolsKey key(array);
-  Object* obj = EnsureCapacity(1, &key);
-  if (obj->IsFailure()) return obj;
 
   MapCache* cache = reinterpret_cast<MapCache*>(obj);
   int entry = cache->FindInsertionEntry(key.Hash());
   cache->set(EntryToIndex(entry), array);
   cache->set(EntryToIndex(entry) + 1, value);
   cache->ElementAdded();
   return cache;
 }
 
 
 template<typename Shape, typename Key>
 Object* Dictionary<Shape, Key>::Allocate(int at_least_space_for) {
   Object* obj = HashTable<Shape, Key>::Allocate(at_least_space_for);
   // Initialize the next enumeration index.
   if (!obj->IsFailure()) {
     Dictionary<Shape, Key>::cast(obj)->
         SetNextEnumerationIndex(PropertyDetails::kInitialIndex);
   }
   return obj;
 }
 
 
 template<typename Shape, typename Key>
 Object* Dictionary<Shape, Key>::GenerateNewEnumerationIndices() {
   int length = HashTable<Shape, Key>::NumberOfElements();
 
+  Object* obj;
+  { TryAllocation t = Heap::AllocateFixedArray(length);
+    if (!t->ToObject(&obj)) return t;
+  }
   // Allocate and initialize iteration order array.
-  Object* obj = Heap::AllocateFixedArray(length);
-  if (obj->IsFailure()) return obj;
   FixedArray* iteration_order = FixedArray::cast(obj);
   for (int i = 0; i < length; i++) {
     iteration_order->set(i, Smi::FromInt(i));
   }
 
+  { TryAllocation t = Heap::AllocateFixedArray(length);
+    if (!t->ToObject(&obj)) return t;
+  }
   // Allocate array with enumeration order.
-  obj = Heap::AllocateFixedArray(length);
-  if (obj->IsFailure()) return obj;
   FixedArray* enumeration_order = FixedArray::cast(obj);
 
   // Fill the enumeration order array with property details.
   int capacity = HashTable<Shape, Key>::Capacity();
   int pos = 0;
   for (int i = 0; i < capacity; i++) {
     if (Dictionary<Shape, Key>::IsKey(Dictionary<Shape, Key>::KeyAt(i))) {
       enumeration_order->set(pos++, Smi::FromInt(DetailsAt(i).index()));
     }
   }
@@ skipping 24 matching lines @@
   // Set the next enumeration index.
   SetNextEnumerationIndex(PropertyDetails::kInitialIndex+length);
   return this;
 }
 
 template<typename Shape, typename Key>
 Object* Dictionary<Shape, Key>::EnsureCapacity(int n, Key key) {
   // Check whether there are enough enumeration indices to add n elements.
   if (Shape::kIsEnumerable &&
       !PropertyDetails::IsValidIndex(NextEnumerationIndex() + n)) {
+    Object* result;
+    { TryAllocation t = GenerateNewEnumerationIndices();
+      if (!t->ToObject(&result)) return t;
+    }
     // If not, we generate new indices for the properties.
-    Object* result = GenerateNewEnumerationIndices();
-    if (result->IsFailure()) return result;
   }
   return HashTable<Shape, Key>::EnsureCapacity(n, key);
 }
 
 
 void NumberDictionary::RemoveNumberEntries(uint32_t from, uint32_t to) {
   // Do nothing if the interval [from, to) is empty.
   if (from >= to) return;
 
   int removed_entries = 0;
@@ skipping 32 matching lines @@
 template<typename Shape, typename Key>
 Object* Dictionary<Shape, Key>::AtPut(Key key, Object* value) {
   int entry = this->FindEntry(key);
 
   // If the entry is present set the value;
   if (entry != Dictionary<Shape, Key>::kNotFound) {
     ValueAtPut(entry, value);
     return this;
   }
 
+  Object* obj;
+  { TryAllocation t = EnsureCapacity(1, key);
+    if (!t->ToObject(&obj)) return t;
+  }
   // Check whether the dictionary should be extended.
-  Object* obj = EnsureCapacity(1, key);
-  if (obj->IsFailure()) return obj;
+  Object* k;
+  { TryAllocation t = Shape::AsObject(key);
+    if (!t->ToObject(&k)) return t;
+  }
 
-  Object* k = Shape::AsObject(key);
-  if (k->IsFailure()) return k;
   PropertyDetails details = PropertyDetails(NONE, NORMAL);
   return Dictionary<Shape, Key>::cast(obj)->
       AddEntry(key, value, details, Shape::Hash(key));
 }
 
 
 template<typename Shape, typename Key>
 Object* Dictionary<Shape, Key>::Add(Key key,
                                     Object* value,
                                     PropertyDetails details) {
   // Valdate key is absent.
   SLOW_ASSERT((this->FindEntry(key) == Dictionary<Shape, Key>::kNotFound));
+  Object* obj;
+  { TryAllocation t = EnsureCapacity(1, key);
+    if (!t->ToObject(&obj)) return t;
+  }
   // Check whether the dictionary should be extended.
-  Object* obj = EnsureCapacity(1, key);
-  if (obj->IsFailure()) return obj;
   return Dictionary<Shape, Key>::cast(obj)->
       AddEntry(key, value, details, Shape::Hash(key));
 }
 
 
 // Add a key, value pair to the dictionary.
 template<typename Shape, typename Key>
 Object* Dictionary<Shape, Key>::AddEntry(Key key,
                                          Object* value,
                                          PropertyDetails details,
                                          uint32_t hash) {
+  Object* k;
+  { TryAllocation t = Shape::AsObject(key);
+    if (!t->ToObject(&k)) return t;
+  }
   // Compute the key object.
-  Object* k = Shape::AsObject(key);
-  if (k->IsFailure()) return k;
 
   uint32_t entry = Dictionary<Shape, Key>::FindInsertionEntry(hash);
   // Insert element at empty or deleted entry
   if (!details.IsDeleted() && details.index() == 0 && Shape::kIsEnumerable) {
     // Assign an enumeration index to the property and update
     // SetNextEnumerationIndex.
     int index = NextEnumerationIndex();
     details = PropertyDetails(details.attributes(), details.type(), index);
     SetNextEnumerationIndex(index + 1);
   }
@@ skipping 159 matching lines @@
     JSObject* obj, int unused_property_fields) {
   // Make sure we preserve dictionary representation if there are too many
   // descriptors.
   if (NumberOfElements() > DescriptorArray::kMaxNumberOfDescriptors) return obj;
 
   // Figure out if it is necessary to generate new enumeration indices.
   int max_enumeration_index =
       NextEnumerationIndex() +
           (DescriptorArray::kMaxNumberOfDescriptors -
            NumberOfElements());
+    Object* result;
+    { TryAllocation t = GenerateNewEnumerationIndices();
+      if (!t->ToObject(&result)) return t;
+    }
   if (!PropertyDetails::IsValidIndex(max_enumeration_index)) {
-    Object* result = GenerateNewEnumerationIndices();
-    if (result->IsFailure()) return result;
   }
 
   int instance_descriptor_length = 0;
   int number_of_fields = 0;
 
   // Compute the length of the instance descriptor.
   int capacity = Capacity();
   for (int i = 0; i < capacity; i++) {
     Object* k = KeyAt(i);
     if (IsKey(k)) {
       Object* value = ValueAt(i);
       PropertyType type = DetailsAt(i).type();
       ASSERT(type != FIELD);
       instance_descriptor_length++;
       if (type == NORMAL &&
           (!value->IsJSFunction() || Heap::InNewSpace(value))) {
         number_of_fields += 1;
       }
     }
   }
 
   // Allocate the instance descriptor.
-  Object* descriptors_unchecked =
-      DescriptorArray::Allocate(instance_descriptor_length);
-  if (descriptors_unchecked->IsFailure()) return descriptors_unchecked;
+  Object* descriptors_unchecked;
+  { TryAllocation t =
+        DescriptorArray::Allocate(instance_descriptor_length);
+    if (!t->ToObject(&descriptors_unchecked)) return t;
+  }
   DescriptorArray* descriptors = DescriptorArray::cast(descriptors_unchecked);
 
   int inobject_props = obj->map()->inobject_properties();
   int number_of_allocated_fields =
       number_of_fields + unused_property_fields - inobject_props;
 
+  Object* fields;
+  { TryAllocation t = Heap::AllocateFixedArray(number_of_allocated_fields);
+    if (!t->ToObject(&fields)) return t;
+  }
   // Allocate the fixed array for the fields.
-  Object* fields = Heap::AllocateFixedArray(number_of_allocated_fields);
-  if (fields->IsFailure()) return fields;
 
   // Fill in the instance descriptor and the fields.
   int next_descriptor = 0;
   int current_offset = 0;
   for (int i = 0; i < capacity; i++) {
     Object* k = KeyAt(i);
     if (IsKey(k)) {
       Object* value = ValueAt(i);
+      Object* key;
+      { TryAllocation t = Heap::LookupSymbol(String::cast(k));
+        if (!t->ToObject(&key)) return t;
+      }
       // Ensure the key is a symbol before writing into the instance descriptor.
-      Object* key = Heap::LookupSymbol(String::cast(k));
-      if (key->IsFailure()) return key;
       PropertyDetails details = DetailsAt(i);
       PropertyType type = details.type();
 
       if (value->IsJSFunction() && !Heap::InNewSpace(value)) {
         ConstantFunctionDescriptor d(String::cast(key),
                                      JSFunction::cast(value),
                                      details.attributes(),
                                      details.index());
         descriptors->Set(next_descriptor++, &d);
       } else if (type == NORMAL) {
@@ skipping 17 matching lines @@
                               details.index());
         descriptors->Set(next_descriptor++, &d);
       } else {
         UNREACHABLE();
       }
     }
   }
   ASSERT(current_offset == number_of_fields);
 
   descriptors->Sort();
+  Object* new_map;
+  { TryAllocation t = obj->map()->CopyDropDescriptors();
+    if (!t->ToObject(&new_map)) return t;
+  }
   // Allocate new map.
-  Object* new_map = obj->map()->CopyDropDescriptors();
-  if (new_map->IsFailure()) return new_map;
 
   // Transform the object.
   obj->set_map(Map::cast(new_map));
   obj->map()->set_instance_descriptors(descriptors);
   obj->map()->set_unused_property_fields(unused_property_fields);
 
   obj->set_properties(FixedArray::cast(fields));
   ASSERT(obj->IsJSObject());
 
   descriptors->SetNextEnumerationIndex(NextEnumerationIndex());
@@ skipping 245 matching lines @@
   if (break_point_objects()->IsUndefined()) return 0;
   // Single beak point.
   if (!break_point_objects()->IsFixedArray()) return 1;
   // Multiple break points.
   return FixedArray::cast(break_point_objects())->length();
 }
 #endif
 
 
 } }  // namespace v8::internal