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

src/runtime.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 84 matching lines @@
   RUNTIME_ASSERT(obj->IsNumber());                                   \
   type name = NumberTo##Type(obj);
 
 // Non-reentrant string buffer for efficient general use in this file.
 static StaticResource<StringInputBuffer> runtime_string_input_buffer;
 
 
 MUST_USE_RESULT static Object* DeepCopyBoilerplate(JSObject* boilerplate) {
   StackLimitCheck check;
   if (check.HasOverflowed()) return Top::StackOverflow();
+  Object* result;
+  { TryAllocation t = Heap::CopyJSObject(boilerplate);
+    if (!t->ToObject(&result)) return t;
+  }
 
-  Object* result = Heap::CopyJSObject(boilerplate);
-  if (result->IsFailure()) return result;
   JSObject* copy = JSObject::cast(result);
 
   // Deep copy local properties.
   if (copy->HasFastProperties()) {
     FixedArray* properties = copy->properties();
     for (int i = 0; i < properties->length(); i++) {
       Object* value = properties->get(i);
       if (value->IsJSObject()) {
+        { TryAllocation t = DeepCopyBoilerplate(js_object);
+          if (!t->ToObject(&result)) return t;
+        }
         JSObject* js_object = JSObject::cast(value);
-        result = DeepCopyBoilerplate(js_object);
-        if (result->IsFailure()) return result;
         properties->set(i, result);
       }
     }
     int nof = copy->map()->inobject_properties();
     for (int i = 0; i < nof; i++) {
       Object* value = copy->InObjectPropertyAt(i);
       if (value->IsJSObject()) {
+        { TryAllocation t = DeepCopyBoilerplate(js_object);
+          if (!t->ToObject(&result)) return t;
+        }
         JSObject* js_object = JSObject::cast(value);
-        result = DeepCopyBoilerplate(js_object);
-        if (result->IsFailure()) return result;
         copy->InObjectPropertyAtPut(i, result);
       }
     }
+    { TryAllocation t =
+          Heap::AllocateFixedArray(copy->NumberOfLocalProperties(NONE));
+      if (!t->ToObject(&result)) return t;
+    }
   } else {
-    result = Heap::AllocateFixedArray(copy->NumberOfLocalProperties(NONE));
-    if (result->IsFailure()) return result;
     FixedArray* names = FixedArray::cast(result);
     copy->GetLocalPropertyNames(names, 0);
     for (int i = 0; i < names->length(); i++) {
       ASSERT(names->get(i)->IsString());
       String* key_string = String::cast(names->get(i));
       PropertyAttributes attributes =
           copy->GetLocalPropertyAttribute(key_string);
       // Only deep copy fields from the object literal expression.
       // In particular, don't try to copy the length attribute of
       // an array.
       if (attributes != NONE) continue;
       Object* value = copy->GetProperty(key_string, &attributes);
       ASSERT(!value->IsFailure());
       if (value->IsJSObject()) {
+        { TryAllocation t = DeepCopyBoilerplate(js_object);
+          if (!t->ToObject(&result)) return t;
+        }
         JSObject* js_object = JSObject::cast(value);
-        result = DeepCopyBoilerplate(js_object);
-        if (result->IsFailure()) return result;
-        result = copy->SetProperty(key_string, result, NONE);
-        if (result->IsFailure()) return result;
+        { TryAllocation t = copy->SetProperty(key_string, result, NONE);
+          if (!t->ToObject(&result)) return t;
+        }
       }
     }
   }
 
   // Deep copy local elements.
   // Pixel elements cannot be created using an object literal.
   ASSERT(!copy->HasPixelElements() && !copy->HasExternalArrayElements());
   switch (copy->GetElementsKind()) {
     case JSObject::FAST_ELEMENTS: {
       FixedArray* elements = FixedArray::cast(copy->elements());
       if (elements->map() == Heap::fixed_cow_array_map()) {
         Counters::cow_arrays_created_runtime.Increment();
 #ifdef DEBUG
         for (int i = 0; i < elements->length(); i++) {
           ASSERT(!elements->get(i)->IsJSObject());
         }
 #endif
       } else {
         for (int i = 0; i < elements->length(); i++) {
           Object* value = elements->get(i);
           if (value->IsJSObject()) {
+            { TryAllocation t = DeepCopyBoilerplate(js_object);
+              if (!t->ToObject(&result)) return t;
+            }
             JSObject* js_object = JSObject::cast(value);
-            result = DeepCopyBoilerplate(js_object);
-            if (result->IsFailure()) return result;
             elements->set(i, result);
           }
         }
       }
       break;
     }
     case JSObject::DICTIONARY_ELEMENTS: {
       NumberDictionary* element_dictionary = copy->element_dictionary();
       int capacity = element_dictionary->Capacity();
       for (int i = 0; i < capacity; i++) {
         Object* k = element_dictionary->KeyAt(i);
         if (element_dictionary->IsKey(k)) {
           Object* value = element_dictionary->ValueAt(i);
           if (value->IsJSObject()) {
+            { TryAllocation t = DeepCopyBoilerplate(js_object);
+              if (!t->ToObject(&result)) return t;
+            }
             JSObject* js_object = JSObject::cast(value);
-            result = DeepCopyBoilerplate(js_object);
-            if (result->IsFailure()) return result;
             element_dictionary->ValueAtPut(i, result);
           }
         }
       }
       break;
     }
     default:
       UNREACHABLE();
       break;
   }
@@ skipping 306 matching lines @@
   return Heap::CopyJSObject(JSObject::cast(*boilerplate));
 }
 
 
 static Object* Runtime_CreateCatchExtensionObject(Arguments args) {
   ASSERT(args.length() == 2);
   CONVERT_CHECKED(String, key, args[0]);
   Object* value = args[1];
   // Create a catch context extension object.
   JSFunction* constructor =
+  Object* object;
+  { TryAllocation t = Heap::AllocateJSObject(constructor);
+    if (!t->ToObject(&object)) return t;
+  }
       Top::context()->global_context()->context_extension_function();
-  Object* object = Heap::AllocateJSObject(constructor);
-  if (object->IsFailure()) return object;
   // Assign the exception value to the catch variable and make sure
+  { TryAllocation t =
+        JSObject::cast(object)->SetProperty(key, value, DONT_DELETE);
+    if (!t->ToObject(&value)) return t;
+  }
   // that the catch variable is DontDelete.
-  value = JSObject::cast(object)->SetProperty(key, value, DONT_DELETE);
-  if (value->IsFailure()) return value;
   return object;
 }
 
 
 static Object* Runtime_ClassOf(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 1);
   Object* obj = args[0];
   if (!obj->IsJSObject()) return Heap::null_value();
   return JSObject::cast(obj)->class_name();
@@ skipping 22 matching lines @@
   CONVERT_CHECKED(JSObject, jsobject, args[0]);
   CONVERT_CHECKED(JSObject, proto, args[1]);
 
   // Sanity checks.  The old prototype (that we are replacing) could
   // theoretically be null, but if it is not null then check that we
   // didn't already install a hidden prototype here.
   RUNTIME_ASSERT(!jsobject->GetPrototype()->IsHeapObject() ||
     !HeapObject::cast(jsobject->GetPrototype())->map()->is_hidden_prototype());
   RUNTIME_ASSERT(!proto->map()->is_hidden_prototype());
 
+  Object* map_or_failure;
+  { TryAllocation t = proto->map()->CopyDropTransitions();
+    if (!t->ToObject(&map_or_failure)) return t;
+  }
   // Allocate up front before we start altering state in case we get a GC.
-  Object* map_or_failure = proto->map()->CopyDropTransitions();
-  if (map_or_failure->IsFailure()) return map_or_failure;
   Map* new_proto_map = Map::cast(map_or_failure);
+  { TryAllocation t = jsobject->map()->CopyDropTransitions();
+    if (!t->ToObject(&map_or_failure)) return t;
+  }
 
-  map_or_failure = jsobject->map()->CopyDropTransitions();
-  if (map_or_failure->IsFailure()) return map_or_failure;
   Map* new_map = Map::cast(map_or_failure);
 
   // Set proto's prototype to be the old prototype of the object.
   new_proto_map->set_prototype(jsobject->GetPrototype());
   proto->set_map(new_proto_map);
   new_proto_map->set_is_hidden_prototype();
 
   // Set the object's prototype to proto.
   new_map->set_prototype(proto);
   jsobject->set_map(new_map);
@@ skipping 125 matching lines @@
   GetOwnPropertyImplementation(*obj, *name, &result);
 
   if (!result.IsProperty()) {
     return Heap::undefined_value();
   }
   if (result.type() == CALLBACKS) {
     Object* structure = result.GetCallbackObject();
     if (structure->IsProxy() || structure->IsAccessorInfo()) {
       // Property that is internally implemented as a callback or
       // an API defined callback.
-      Object* value = obj->GetPropertyWithCallback(
-          *obj, structure, *name, result.holder());
-      if (value->IsFailure()) return value;
+      Object* value;
+      { TryAllocation t = obj->GetPropertyWithCallback(
+            *obj, structure, *name, result.holder());
+        if (!t->ToObject(&value)) return t;
+      }
       elms->set(IS_ACCESSOR_INDEX, Heap::false_value());
       elms->set(VALUE_INDEX, value);
       elms->set(WRITABLE_INDEX, Heap::ToBoolean(!result.IsReadOnly()));
     } else if (structure->IsFixedArray()) {
       // __defineGetter__/__defineSetter__ callback.
       elms->set(IS_ACCESSOR_INDEX, Heap::true_value());
       elms->set(GETTER_INDEX, FixedArray::cast(structure)->get(0));
       elms->set(SETTER_INDEX, FixedArray::cast(structure)->get(1));
     } else {
       return Heap::undefined_value();
@@ skipping 70 matching lines @@
   return *HeapObject::RawField(templ, offset);
 }
 
 
 static Object* Runtime_DisableAccessChecks(Arguments args) {
   ASSERT(args.length() == 1);
   CONVERT_CHECKED(HeapObject, object, args[0]);
   Map* old_map = object->map();
   bool needs_access_checks = old_map->is_access_check_needed();
   if (needs_access_checks) {
+    Object* new_map;
+    { TryAllocation t = old_map->CopyDropTransitions();
+      if (!t->ToObject(&new_map)) return t;
+    }
     // Copy map so it won't interfere constructor's initial map.
-    Object* new_map = old_map->CopyDropTransitions();
-    if (new_map->IsFailure()) return new_map;
 
     Map::cast(new_map)->set_is_access_check_needed(false);
     object->set_map(Map::cast(new_map));
   }
   return needs_access_checks ? Heap::true_value() : Heap::false_value();
 }
 
 
 static Object* Runtime_EnableAccessChecks(Arguments args) {
   ASSERT(args.length() == 1);
   CONVERT_CHECKED(HeapObject, object, args[0]);
   Map* old_map = object->map();
   if (!old_map->is_access_check_needed()) {
+    Object* new_map;
+    { TryAllocation t = old_map->CopyDropTransitions();
+      if (!t->ToObject(&new_map)) return t;
+    }
     // Copy map so it won't interfere constructor's initial map.
-    Object* new_map = old_map->CopyDropTransitions();
-    if (new_map->IsFailure()) return new_map;
 
     Map::cast(new_map)->set_is_access_check_needed(true);
     object->set_map(Map::cast(new_map));
   }
   return Heap::undefined_value();
 }
 
 
 static Object* ThrowRedeclarationError(const char* type, Handle<String> name) {
   HandleScope scope;
@@ skipping 515 matching lines @@
   if (result.is_null()) return Failure::Exception();
   return *result;
 }
 
 
 static Object* Runtime_RegExpConstructResult(Arguments args) {
   ASSERT(args.length() == 3);
   CONVERT_SMI_CHECKED(elements_count, args[0]);
   if (elements_count > JSArray::kMaxFastElementsLength) {
     return Top::ThrowIllegalOperation();
+  Object* new_object;
+  { TryAllocation t = Heap::AllocateFixedArrayWithHoles(elements_count);
+    if (!t->ToObject(&new_object)) return t;
   }
-  Object* new_object = Heap::AllocateFixedArrayWithHoles(elements_count);
-  if (new_object->IsFailure()) return new_object;
+  }
   FixedArray* elements = FixedArray::cast(new_object);
   new_object = Heap::AllocateRaw(JSRegExpResult::kSize,
                                  NEW_SPACE,
                                  OLD_POINTER_SPACE);
   if (new_object->IsFailure()) return new_object;
   {
     AssertNoAllocation no_gc;
     HandleScope scope;
     reinterpret_cast<HeapObject*>(new_object)->
         set_map(Top::global_context()->regexp_result_map());
@@ skipping 220 matching lines @@
   CONVERT_CHECKED(String, name, args[1]);
   f->shared()->set_name(name);
   return Heap::undefined_value();
 }
 
 
 static Object* Runtime_FunctionRemovePrototype(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 1);
 
+  Object* obj;
+  { TryAllocation t = f->RemovePrototype();
+    if (!t->ToObject(&obj)) return t;
+  }
   CONVERT_CHECKED(JSFunction, f, args[0]);
-  Object* obj = f->RemovePrototype();
-  if (obj->IsFailure()) return obj;
 
   return Heap::undefined_value();
 }
 
 
 static Object* Runtime_FunctionGetScript(Arguments args) {
   HandleScope scope;
   ASSERT(args.length() == 1);
 
   CONVERT_CHECKED(JSFunction, fun, args[0]);
@@ skipping 58 matching lines @@
   fun->shared()->set_length(length->value());
   return length;
 }
 
 
 static Object* Runtime_FunctionSetPrototype(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 2);
 
   CONVERT_CHECKED(JSFunction, fun, args[0]);
+  Object* obj;
+  { TryAllocation t = Accessors::FunctionSetPrototype(fun, args[1], NULL);
+    if (!t->ToObject(&obj)) return t;
+  }
   ASSERT(fun->should_have_prototype());
-  Object* obj = Accessors::FunctionSetPrototype(fun, args[1], NULL);
-  if (obj->IsFailure()) return obj;
   return args[0];  // return TOS
 }
 
 
 static Object* Runtime_FunctionIsAPIFunction(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 1);
 
   CONVERT_CHECKED(JSFunction, f, args[0]);
   return f->shared()->IsApiFunction() ? Heap::true_value()
@@ skipping 102 matching lines @@
     if (value < 0) return Heap::nan_value();
     i = value;
   } else {
     ASSERT(index->IsHeapNumber());
     double value = HeapNumber::cast(index)->value();
     i = static_cast<uint32_t>(DoubleToInteger(value));
   }
 
   // Flatten the string.  If someone wants to get a char at an index
   // in a cons string, it is likely that more indices will be
+  Object* flat;
+  { TryAllocation t = subject->TryFlatten();
+    if (!t->ToObject(&flat)) return t;
+  }
   // accessed.
-  Object* flat = subject->TryFlatten();
-  if (flat->IsFailure()) return flat;
   subject = String::cast(flat);
 
   if (i >= static_cast<uint32_t>(subject->length())) {
     return Heap::nan_value();
   }
 
   return Smi::FromInt(subject->Get(i));
 }
 
 
@@ skipping 1670 matching lines @@
   RUNTIME_ASSERT(!obj->IsNull());
   LookupResult result;
   obj->LocalLookupRealNamedProperty(name, &result);
 
   PropertyAttributes attr = static_cast<PropertyAttributes>(unchecked);
   // If an existing property is either FIELD, NORMAL or CONSTANT_FUNCTION
   // delete it to avoid running into trouble in DefineAccessor, which
   // handles this incorrectly if the property is readonly (does nothing)
   if (result.IsProperty() &&
       (result.type() == FIELD || result.type() == NORMAL
+    Object* ok;
+    { TryAllocation t = obj->DeleteProperty(name, JSObject::NORMAL_DELETION);
+      if (!t->ToObject(&ok)) return t;
+    }
        || result.type() == CONSTANT_FUNCTION)) {
-    Object* ok = obj->DeleteProperty(name, JSObject::NORMAL_DELETION);
-    if (ok->IsFailure()) return ok;
   }
   return obj->DefineAccessor(name, flag_setter->value() == 0, fun, attr);
 }
 
 static Object* Runtime_DefineOrRedefineDataProperty(Arguments args) {
   ASSERT(args.length() == 4);
   HandleScope scope;
   CONVERT_ARG_CHECKED(JSObject, js_object, 0);
   CONVERT_ARG_CHECKED(String, name, 1);
   Handle<Object> obj_value = args.at<Object>(2);
@@ skipping 854 matching lines @@
       ASSERT(String::kMaxLength < 0x7fffffff - 6);  // Cannot overflow.
       if (escaped_length > String::kMaxLength) {
         Top::context()->mark_out_of_memory();
         return Failure::OutOfMemoryException();
       }
     }
   }
   // No length change implies no change.  Return original string if no change.
   if (escaped_length == length) {
     return source;
+  Object* o;
+  { TryAllocation t = Heap::AllocateRawAsciiString(escaped_length);
+    if (!t->ToObject(&o)) return t;
   }
-  Object* o = Heap::AllocateRawAsciiString(escaped_length);
-  if (o->IsFailure()) return o;
+  }
   String* destination = String::cast(o);
   int dest_position = 0;
 
   Access<StringInputBuffer> buffer(&runtime_string_input_buffer);
   buffer->Rewind();
   while (buffer->has_more()) {
     uint16_t chr = buffer->GetNext();
     if (chr >= 256) {
       destination->Set(dest_position, '%');
       destination->Set(dest_position+1, 'u');
@@ skipping 284 matching lines @@
   const int length = s->length();
   // Assume that the string is not empty; we need this assumption later
   if (length == 0) return s;
 
   // Simpler handling of ascii strings.
   //
   // NOTE: This assumes that the upper/lower case of an ascii
   // character is also ascii.  This is currently the case, but it
   // might break in the future if we implement more context and locale
   // dependent upper/lower conversions.
+    Object* o;
+    { TryAllocation t = Heap::AllocateRawAsciiString(length);
+      if (!t->ToObject(&o)) return t;
+    }
   if (s->IsSeqAsciiString()) {
-    Object* o = Heap::AllocateRawAsciiString(length);
-    if (o->IsFailure()) return o;
     SeqAsciiString* result = SeqAsciiString::cast(o);
     bool has_changed_character = ConvertTraits::ConvertAscii(
         result->GetChars(), SeqAsciiString::cast(s)->GetChars(), length);
     return has_changed_character ? result : s;
   }
 
   Object* answer = ConvertCaseHelper(s, length, length, mapping);
   if (answer->IsSmi()) {
     // Retry with correct length.
     answer = ConvertCaseHelper(s, Smi::cast(answer)->value(), length, mapping);
@@ skipping 194 matching lines @@
 // For example, "foo" => ["f", "o", "o"].
 static Object* Runtime_StringToArray(Arguments args) {
   HandleScope scope;
   ASSERT(args.length() == 1);
   CONVERT_ARG_CHECKED(String, s, 0);
 
   s->TryFlatten();
   const int length = s->length();
 
   Handle<FixedArray> elements;
+    Object* obj;
+    { TryAllocation t = Heap::AllocateUninitializedFixedArray(length);
+      if (!t->ToObject(&obj)) return t;
+    }
   if (s->IsFlat() && s->IsAsciiRepresentation()) {
-    Object* obj = Heap::AllocateUninitializedFixedArray(length);
-    if (obj->IsFailure()) return obj;
     elements = Handle<FixedArray>(FixedArray::cast(obj));
 
     Vector<const char> chars = s->ToAsciiVector();
     // Note, this will initialize all elements (not only the prefix)
     // to prevent GC from seeing partially initialized array.
     int num_copied_from_cache = CopyCachedAsciiCharsToArray(chars.start(),
                                                             *elements,
                                                             length);
 
     for (int i = num_copied_from_cache; i < length; ++i) {
@@ skipping 331 matching lines @@
     if (increment > String::kMaxLength - position) {
       Top::context()->mark_out_of_memory();
       return Failure::OutOfMemoryException();
     }
     position += increment;
   }
 
   int length = position;
   Object* object;
 
+    { TryAllocation t = Heap::AllocateRawAsciiString(length);
+      if (!t->ToObject(&object)) return t;
+    }
   if (ascii) {
-    object = Heap::AllocateRawAsciiString(length);
-    if (object->IsFailure()) return object;
     SeqAsciiString* answer = SeqAsciiString::cast(object);
     StringBuilderConcatHelper(special,
                               answer->GetChars(),
                               fixed_array,
                               array_length);
     return answer;
+    { TryAllocation t = Heap::AllocateRawTwoByteString(length);
+      if (!t->ToObject(&object)) return t;
+    }
   } else {
-    object = Heap::AllocateRawTwoByteString(length);
-    if (object->IsFailure()) return object;
     SeqTwoByteString* answer = SeqTwoByteString::cast(object);
     StringBuilderConcatHelper(special,
                               answer->GetChars(),
                               fixed_array,
                               array_length);
     return answer;
   }
 }
 
 
@@ skipping 250 matching lines @@
   if (y->length() == 0) {
     if (x->length() == 0) return Smi::FromInt(EQUAL);
     return Smi::FromInt(GREATER);
   } else if (x->length() == 0) {
     return Smi::FromInt(LESS);
   }
 
   int d = x->Get(0) - y->Get(0);
   if (d < 0) return Smi::FromInt(LESS);
   else if (d > 0) return Smi::FromInt(GREATER);
+  Object* obj;
+  { TryAllocation t = Heap::PrepareForCompare(x);
+    if (!t->ToObject(&obj)) return t;
+  }
 
-  Object* obj = Heap::PrepareForCompare(x);
-  if (obj->IsFailure()) return obj;
-  obj = Heap::PrepareForCompare(y);
-  if (obj->IsFailure()) return obj;
+  { TryAllocation t = Heap::PrepareForCompare(y);
+    if (!t->ToObject(&obj)) return t;
+  }
 
   return (x->IsFlat() && y->IsFlat()) ? FlatStringCompare(x, y)
                                       : StringInputBufferCompare(x, y);
 }
 
 
 static Object* Runtime_Math_acos(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 1);
   Counters::math_acos.Increment();
@@ skipping 615 matching lines @@
 }
 
 
 static Object* Runtime_NewArgumentsFast(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 3);
 
   JSFunction* callee = JSFunction::cast(args[0]);
   Object** parameters = reinterpret_cast<Object**>(args[1]);
   const int length = Smi::cast(args[2])->value();
+  Object* result;
+  { TryAllocation t = Heap::AllocateArgumentsObject(callee, length);
+    if (!t->ToObject(&result)) return t;
+  }
 
-  Object* result = Heap::AllocateArgumentsObject(callee, length);
-  if (result->IsFailure()) return result;
   // Allocate the elements if needed.
   if (length > 0) {
+    Object* obj;
+    { TryAllocation t = Heap::AllocateRawFixedArray(length);
+      if (!t->ToObject(&obj)) return t;
+    }
     // Allocate the fixed array.
-    Object* obj = Heap::AllocateRawFixedArray(length);
-    if (obj->IsFailure()) return obj;
 
     AssertNoAllocation no_gc;
     FixedArray* array = reinterpret_cast<FixedArray*>(obj);
     array->set_map(Heap::fixed_array_map());
     array->set_length(length);
 
     WriteBarrierMode mode = array->GetWriteBarrierMode(no_gc);
     for (int i = 0; i < length; i++) {
       array->set(i, *--parameters, mode);
     }
@@ skipping 190 matching lines @@
   RUNTIME_ASSERT(!args[0]->IsJSFunction());
   return *Execution::GetConstructorDelegate(args.at<Object>(0));
 }
 
 
 static Object* Runtime_NewContext(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 1);
 
   CONVERT_CHECKED(JSFunction, function, args[0]);
+  Object* result;
+  { TryAllocation t = Heap::AllocateFunctionContext(length, function);
+    if (!t->ToObject(&result)) return t;
+  }
   int length = function->shared()->scope_info()->NumberOfContextSlots();
-  Object* result = Heap::AllocateFunctionContext(length, function);
-  if (result->IsFailure()) return result;
 
   Top::set_context(Context::cast(result));
 
   return result;  // non-failure
 }
 
 static Object* PushContextHelper(Object* object, bool is_catch_context) {
   // Convert the object to a proper JavaScript object.
   Object* js_object = object;
   if (!js_object->IsJSObject()) {
@@ skipping 683 matching lines @@
 // false otherwise.
 static Object* Runtime_PushIfAbsent(Arguments args) {
   ASSERT(args.length() == 2);
   CONVERT_CHECKED(JSArray, array, args[0]);
   CONVERT_CHECKED(JSArray, element, args[1]);
   RUNTIME_ASSERT(array->HasFastElements());
   int length = Smi::cast(array->length())->value();
   FixedArray* elements = FixedArray::cast(array->elements());
   for (int i = 0; i < length; i++) {
     if (elements->get(i) == element) return Heap::false_value();
+  Object* obj;
+  { TryAllocation t = array->SetFastElement(length, element);
+    if (!t->ToObject(&obj)) return t;
   }
-  Object* obj = array->SetFastElement(length, element);
-  if (obj->IsFailure()) return obj;
+  }
   return Heap::true_value();
 }
 
 
 /**
  * A simple visitor visits every element of Array's.
  * The backend storage can be a fixed array for fast elements case,
  * or a dictionary for sparse array. Since Dictionary is a subtype
  * of FixedArray, the class can be used by both fast and slow cases.
  * The second parameter of the constructor, fast_elements, specifies
@@ skipping 426 matching lines @@
   Object* new_map;
   if (new_elements->map() == Heap::fixed_array_map() ||
       new_elements->map() == Heap::fixed_cow_array_map()) {
     new_map = to->map()->GetFastElementsMap();
   } else {
     new_map = to->map()->GetSlowElementsMap();
   }
   if (new_map->IsFailure()) return new_map;
   to->set_map(Map::cast(new_map));
   to->set_elements(new_elements);
+  Object* obj;
+  { TryAllocation t = from->ResetElements();
+    if (!t->ToObject(&obj)) return t;
+  }
   to->set_length(from->length());
-  Object* obj = from->ResetElements();
-  if (obj->IsFailure()) return obj;
   from->set_length(Smi::FromInt(0));
   return to;
 }
 
 
 // How many elements does this object/array have?
 static Object* Runtime_EstimateNumberOfElements(Arguments args) {
   ASSERT(args.length() == 1);
   CONVERT_CHECKED(JSObject, object, args[0]);
   HeapObject* elements = object->elements();
@@ skipping 264 matching lines @@
       // local variables using handles when required for later use.
       PropertyType result_type = result.type();
       Handle<Object> result_callback_obj;
       if (result_type == CALLBACKS) {
         result_callback_obj = Handle<Object>(result.GetCallbackObject());
       }
       Smi* property_details = result.GetPropertyDetails().AsSmi();
       // DebugLookupResultValue can cause GC so details from LookupResult needs
       // to be copied to handles before this.
       bool caught_exception = false;
-      Object* raw_value = DebugLookupResultValue(*obj, *name, &result,
-                                                 &caught_exception);
-      if (raw_value->IsFailure()) return raw_value;
+      Object* raw_value;
+      { TryAllocation t = DebugLookupResultValue(*obj, *name, &result,
+                                                   &caught_exception);
+        if (!t->ToObject(&raw_value)) return t;
+      }
       Handle<Object> value(raw_value);
 
       // If the callback object is a fixed array then it contains JavaScript
       // getter and/or setter.
       bool hasJavaScriptAccessors = result_type == CALLBACKS &&
                                     result_callback_obj->IsFixedArray();
       Handle<FixedArray> details =
           Factory::NewFixedArray(hasJavaScriptAccessors ? 5 : 2);
       details->set(0, *value);
       details->set(1, property_details);
@@ skipping 101 matching lines @@
   }
 
   return Heap::true_value();
 }
 
 
 static Object* Runtime_GetFrameCount(Arguments args) {
   HandleScope scope;
   ASSERT(args.length() == 1);
 
+  Object* result;
+  { TryAllocation t = Runtime_CheckExecutionState(args);
+    if (!t->ToObject(&result)) return t;
+  }
   // Check arguments.
-  Object* result = Runtime_CheckExecutionState(args);
-  if (result->IsFailure()) return result;
 
   // Count all frames which are relevant to debugging stack trace.
   int n = 0;
   StackFrame::Id id = Debug::break_frame_id();
   if (id == StackFrame::NO_ID) {
     // If there is no JavaScript stack frame count is 0.
     return Smi::FromInt(0);
   }
   for (JavaScriptFrameIterator it(id); !it.done(); it.Advance()) n++;
   return Smi::FromInt(n);
@@ skipping 25 matching lines @@
 // 6: Constructor call
 // 7: Is at return
 // 8: Debugger frame
 // Arguments name, value
 // Locals name, value
 // Return value if any
 static Object* Runtime_GetFrameDetails(Arguments args) {
   HandleScope scope;
   ASSERT(args.length() == 2);
 
+  Object* check;
+  { TryAllocation t = Runtime_CheckExecutionState(args);
+    if (!t->ToObject(&check)) return t;
+  }
   // Check arguments.
-  Object* check = Runtime_CheckExecutionState(args);
-  if (check->IsFailure()) return check;
   CONVERT_NUMBER_CHECKED(int, index, Int32, args[1]);
 
   // Find the relevant frame with the requested index.
   StackFrame::Id id = Debug::break_frame_id();
   if (id == StackFrame::NO_ID) {
     // If there are no JavaScript stack frames return undefined.
     return Heap::undefined_value();
   }
   int count = 0;
   JavaScriptFrameIterator it(id);
@@ skipping 518 matching lines @@
   bool at_local_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ScopeIterator);
 };
 
 
 static Object* Runtime_GetScopeCount(Arguments args) {
   HandleScope scope;
   ASSERT(args.length() == 2);
 
+  Object* check;
+  { TryAllocation t = Runtime_CheckExecutionState(args);
+    if (!t->ToObject(&check)) return t;
+  }
   // Check arguments.
-  Object* check = Runtime_CheckExecutionState(args);
-  if (check->IsFailure()) return check;
   CONVERT_CHECKED(Smi, wrapped_id, args[1]);
 
   // Get the frame where the debugging is performed.
   StackFrame::Id id = UnwrapFrameId(wrapped_id);
   JavaScriptFrameIterator it(id);
   JavaScriptFrame* frame = it.frame();
 
   // Count the visible scopes.
   int n = 0;
   for (ScopeIterator it(frame); !it.Done(); it.Next()) {
@@ skipping 13 matching lines @@
 // args[1]: number: frame index
 // args[2]: number: scope index
 //
 // The array returned contains the following information:
 // 0: Scope type
 // 1: Scope object
 static Object* Runtime_GetScopeDetails(Arguments args) {
   HandleScope scope;
   ASSERT(args.length() == 3);
 
+  Object* check;
+  { TryAllocation t = Runtime_CheckExecutionState(args);
+    if (!t->ToObject(&check)) return t;
+  }
   // Check arguments.
-  Object* check = Runtime_CheckExecutionState(args);
-  if (check->IsFailure()) return check;
   CONVERT_CHECKED(Smi, wrapped_id, args[1]);
   CONVERT_NUMBER_CHECKED(int, index, Int32, args[2]);
 
   // Get the frame where the debugging is performed.
   StackFrame::Id id = UnwrapFrameId(wrapped_id);
   JavaScriptFrameIterator frame_it(id);
   JavaScriptFrame* frame = frame_it.frame();
 
   // Find the requested scope.
   int n = 0;
@@ skipping 29 matching lines @@
   for (ScopeIterator it(frame); !it.Done(); it.Next()) {
     it.DebugPrint();
   }
 #endif
   return Heap::undefined_value();
 }
 
 
 static Object* Runtime_GetCFrames(Arguments args) {
   HandleScope scope;
+  Object* result;
+  { TryAllocation t = Runtime_CheckExecutionState(args);
+    if (!t->ToObject(&result)) return t;
+  }
   ASSERT(args.length() == 1);
-  Object* result = Runtime_CheckExecutionState(args);
-  if (result->IsFailure()) return result;
 
 #if V8_HOST_ARCH_64_BIT
   UNIMPLEMENTED();
   return Heap::undefined_value();
 #else
 
   static const int kMaxCFramesSize = 200;
   ScopedVector<OS::StackFrame> frames(kMaxCFramesSize);
   int frames_count = OS::StackWalk(frames);
   if (frames_count == OS::kStackWalkError) {
@@ skipping 26 matching lines @@
   }
   return *Factory::NewJSArrayWithElements(frames_array);
 #endif  // V8_HOST_ARCH_64_BIT
 }
 
 
 static Object* Runtime_GetThreadCount(Arguments args) {
   HandleScope scope;
   ASSERT(args.length() == 1);
 
+  Object* result;
+  { TryAllocation t = Runtime_CheckExecutionState(args);
+    if (!t->ToObject(&result)) return t;
+  }
   // Check arguments.
-  Object* result = Runtime_CheckExecutionState(args);
-  if (result->IsFailure()) return result;
 
   // Count all archived V8 threads.
   int n = 0;
   for (ThreadState* thread = ThreadState::FirstInUse();
        thread != NULL;
        thread = thread->Next()) {
     n++;
   }
 
   // Total number of threads is current thread and archived threads.
   return Smi::FromInt(n + 1);
 }
 
 
 static const int kThreadDetailsCurrentThreadIndex = 0;
 static const int kThreadDetailsThreadIdIndex = 1;
 static const int kThreadDetailsSize = 2;
 
 // Return an array with thread details
 // args[0]: number: break id
 // args[1]: number: thread index
 //
 // The array returned contains the following information:
 // 0: Is current thread?
 // 1: Thread id
 static Object* Runtime_GetThreadDetails(Arguments args) {
   HandleScope scope;
   ASSERT(args.length() == 2);
 
+  Object* check;
+  { TryAllocation t = Runtime_CheckExecutionState(args);
+    if (!t->ToObject(&check)) return t;
+  }
   // Check arguments.
-  Object* check = Runtime_CheckExecutionState(args);
-  if (check->IsFailure()) return check;
   CONVERT_NUMBER_CHECKED(int, index, Int32, args[1]);
 
   // Allocate array for result.
   Handle<FixedArray> details = Factory::NewFixedArray(kThreadDetailsSize);
 
   // Thread index 0 is current thread.
   if (index == 0) {
     // Fill the details.
     details->set(kThreadDetailsCurrentThreadIndex, Heap::true_value());
     details->set(kThreadDetailsThreadIdIndex,
@@ skipping 229 matching lines @@
 
 
 // Prepare for stepping
 // args[0]: break id for checking execution state
 // args[1]: step action from the enumeration StepAction
 // args[2]: number of times to perform the step, for step out it is the number
 //          of frames to step down.
 static Object* Runtime_PrepareStep(Arguments args) {
   HandleScope scope;
   ASSERT(args.length() == 3);
+  Object* check;
+  { TryAllocation t = Runtime_CheckExecutionState(args);
+    if (!t->ToObject(&check)) return t;
+  }
   // Check arguments.
-  Object* check = Runtime_CheckExecutionState(args);
-  if (check->IsFailure()) return check;
   if (!args[1]->IsNumber() || !args[2]->IsNumber()) {
     return Top::Throw(Heap::illegal_argument_symbol());
   }
 
   // Get the step action and check validity.
   StepAction step_action = static_cast<StepAction>(NumberToInt32(args[1]));
   if (step_action != StepIn &&
       step_action != StepNext &&
       step_action != StepOut &&
       step_action != StepInMin &&
@@ skipping 92 matching lines @@
 // function is created as well to be used as the closure for the context.
 // This function and the context acts as replacements for the function on the
 // stack frame presenting the same view of the values of parameters and
 // local variables as if the piece of JavaScript was evaluated at the point
 // where the function on the stack frame is currently stopped.
 static Object* Runtime_DebugEvaluate(Arguments args) {
   HandleScope scope;
 
   // Check the execution state and decode arguments frame and source to be
   // evaluated.
+  Object* check_result;
+  { TryAllocation t = Runtime_CheckExecutionState(args);
+    if (!t->ToObject(&check_result)) return t;
+  }
   ASSERT(args.length() == 4);
-  Object* check_result = Runtime_CheckExecutionState(args);
-  if (check_result->IsFailure()) return check_result;
   CONVERT_CHECKED(Smi, wrapped_id, args[1]);
   CONVERT_ARG_CHECKED(String, source, 2);
   CONVERT_BOOLEAN_CHECKED(disable_break, args[3]);
 
   // Handle the processing of break.
   DisableBreak disable_break_save(disable_break);
 
   // Get the frame where the debugging is performed.
   StackFrame::Id id = UnwrapFrameId(wrapped_id);
   JavaScriptFrameIterator it(id);
@@ skipping 88 matching lines @@
 
   return *result;
 }
 
 
 static Object* Runtime_DebugEvaluateGlobal(Arguments args) {
   HandleScope scope;
 
   // Check the execution state and decode arguments frame and source to be
   // evaluated.
+  Object* check_result;
+  { TryAllocation t = Runtime_CheckExecutionState(args);
+    if (!t->ToObject(&check_result)) return t;
+  }
   ASSERT(args.length() == 3);
-  Object* check_result = Runtime_CheckExecutionState(args);
-  if (check_result->IsFailure()) return check_result;
   CONVERT_ARG_CHECKED(String, source, 1);
   CONVERT_BOOLEAN_CHECKED(disable_break, args[2]);
 
   // Handle the processing of break.
   DisableBreak disable_break_save(disable_break);
 
   // Enter the top context from before the debugger was invoked.
   SaveContext save;
   SaveContext* top = &save;
   while (top != NULL && *top->context() == *Debug::debug_context()) {
@@ skipping 147 matching lines @@
   JSObject* arguments_boilerplate =
       Top::context()->global_context()->arguments_boilerplate();
   JSFunction* arguments_function =
       JSFunction::cast(arguments_boilerplate->map()->constructor());
 
   // Get the number of referencing objects.
   int count;
   count = DebugReferencedBy(target, instance_filter, max_references,
                             NULL, 0, arguments_function);
 
+  Object* object;
+  { TryAllocation t = Heap::AllocateFixedArray(count);
+    if (!t->ToObject(&object)) return t;
+  }
   // Allocate an array to hold the result.
-  Object* object = Heap::AllocateFixedArray(count);
-  if (object->IsFailure()) return object;
   FixedArray* instances = FixedArray::cast(object);
 
   // Fill the referencing objects.
   count = DebugReferencedBy(target, instance_filter, max_references,
                             instances, count, arguments_function);
 
   // Return result as JS array.
   Object* result =
       Heap::AllocateJSObject(
           Top::context()->global_context()->array_function());
@@ skipping 43 matching lines @@
 
   // Check parameters.
   CONVERT_CHECKED(JSFunction, constructor, args[0]);
   CONVERT_NUMBER_CHECKED(int32_t, max_references, Int32, args[1]);
   RUNTIME_ASSERT(max_references >= 0);
 
   // Get the number of referencing objects.
   int count;
   count = DebugConstructedBy(constructor, max_references, NULL, 0);
 
+  Object* object;
+  { TryAllocation t = Heap::AllocateFixedArray(count);
+    if (!t->ToObject(&object)) return t;
+  }
   // Allocate an array to hold the result.
-  Object* object = Heap::AllocateFixedArray(count);
-  if (object->IsFailure()) return object;
   FixedArray* instances = FixedArray::cast(object);
 
   // Fill the referencing objects.
   count = DebugConstructedBy(constructor, max_references, instances, count);
 
   // Return result as JS array.
   Object* result =
       Heap::AllocateJSObject(
           Top::context()->global_context()->array_function());
   if (!result->IsFailure()) JSArray::cast(result)->SetContent(instances);
@@ skipping 654 matching lines @@
 Runtime::Function kIntrinsicFunctions[] = {
   RUNTIME_FUNCTION_LIST(F)
   INLINE_FUNCTION_LIST(I)
   INLINE_RUNTIME_FUNCTION_LIST(I)
 };
 
 
 Object* Runtime::InitializeIntrinsicFunctionNames(Object* dictionary) {
   ASSERT(dictionary != NULL);
   ASSERT(StringDictionary::cast(dictionary)->NumberOfElements() == 0);
+    Object* name_symbol;
+    { TryAllocation t = Heap::LookupAsciiSymbol(kIntrinsicFunctions[i].name);
+      if (!t->ToObject(&name_symbol)) return t;
+    }
   for (int i = 0; i < kNumFunctions; ++i) {
-    Object* name_symbol = Heap::LookupAsciiSymbol(kIntrinsicFunctions[i].name);
-    if (name_symbol->IsFailure()) return name_symbol;
     StringDictionary* string_dictionary = StringDictionary::cast(dictionary);
     dictionary = string_dictionary->Add(String::cast(name_symbol),
                                         Smi::FromInt(i),
                                         PropertyDetails(NONE, NORMAL));
     // Non-recoverable failure.  Calling code must restart heap initialization.
     if (dictionary->IsFailure()) return dictionary;
   }
   return dictionary;
 }
 
@@ skipping 23 matching lines @@
   } else {
     // Handle last resort GC and make sure to allow future allocations
     // to grow the heap without causing GCs (if possible).
     Counters::gc_last_resort_from_js.Increment();
     Heap::CollectAllGarbage(false);
   }
 }
 
 
 } }  // namespace v8::internal