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

src/ic.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 501 matching lines @@
     }
     return TypeError("undefined_method", object, name);
   }
 
   // Lookup is valid: Update inline cache and stub cache.
   if (FLAG_use_ic) {
     UpdateCaches(&lookup, state, object, name);
   }
 
   // Get the property.
+  Object* result;
+  { TryAllocation t = object->GetProperty(*object, &lookup, *name, &attr);
+    if (!t->ToObject(&result)) return t;
+  }
   PropertyAttributes attr;
-  Object* result = object->GetProperty(*object, &lookup, *name, &attr);
-  if (result->IsFailure()) return result;
   if (lookup.type() == INTERCEPTOR) {
     // If the object does not have the requested property, check which
     // exception we need to throw.
     if (attr == ABSENT) {
       if (IsContextual(object)) {
         return ReferenceError("not_defined", name);
       }
       return TypeError("undefined_method", object, name);
     }
   }
@@ skipping 325 matching lines @@
     }
   }
 
   // Update inline cache and stub cache.
   if (FLAG_use_ic) {
     UpdateCaches(&lookup, state, object, name);
   }
 
   PropertyAttributes attr;
   if (lookup.IsProperty() && lookup.type() == INTERCEPTOR) {
+    Object* result;
+    { TryAllocation t = object->GetProperty(*object, &lookup, *name, &attr);
+      if (!t->ToObject(&result)) return t;
+    }
     // Get the property.
-    Object* result = object->GetProperty(*object, &lookup, *name, &attr);
-    if (result->IsFailure()) return result;
     // If the property is not present, check if we need to throw an
     // exception.
     if (attr == ABSENT && IsContextual(object)) {
       return ReferenceError("not_defined", name);
     }
     return result;
   }
 
   // Get the property.
   return object->GetProperty(*object, &lookup, *name, &attr);
@@ skipping 113 matching lines @@
     // If the object is undefined or null it's illegal to try to get any
     // of its properties; throw a TypeError in that case.
     if (object->IsUndefined() || object->IsNull()) {
       return TypeError("non_object_property_load", object, name);
     }
 
     if (FLAG_use_ic) {
       // Use specialized code for getting the length of strings.
       if (object->IsString() && name->Equals(Heap::length_symbol())) {
         Handle<String> string = Handle<String>::cast(object);
+        { TryAllocation t =
+              StubCache::ComputeKeyedLoadStringLength(*name, *string);
+          if (!t->ToObject(&code)) return t;
+        }
         Object* code = NULL;
-        code = StubCache::ComputeKeyedLoadStringLength(*name, *string);
-        if (code->IsFailure()) return code;
         set_target(Code::cast(code));
 #ifdef DEBUG
         TraceIC("KeyedLoadIC", name, state, target());
 #endif  // DEBUG
         return Smi::FromInt(string->length());
       }
 
       // Use specialized code for getting the length of arrays.
       if (object->IsJSArray() && name->Equals(Heap::length_symbol())) {
+        Object* code;
+        { TryAllocation t =
+              StubCache::ComputeKeyedLoadArrayLength(*name, *array);
+          if (!t->ToObject(&code)) return t;
+        }
         Handle<JSArray> array = Handle<JSArray>::cast(object);
-        Object* code = StubCache::ComputeKeyedLoadArrayLength(*name, *array);
-        if (code->IsFailure()) return code;
         set_target(Code::cast(code));
 #ifdef DEBUG
         TraceIC("KeyedLoadIC", name, state, target());
 #endif  // DEBUG
         return JSArray::cast(*object)->length();
       }
 
       // Use specialized code for getting prototype of functions.
       if (object->IsJSFunction() && name->Equals(Heap::prototype_symbol()) &&
         JSFunction::cast(*object)->should_have_prototype()) {
         Handle<JSFunction> function = Handle<JSFunction>::cast(object);
-        Object* code =
-            StubCache::ComputeKeyedLoadFunctionPrototype(*name, *function);
-        if (code->IsFailure()) return code;
+        Object* code;
+        { TryAllocation t =
+              StubCache::ComputeKeyedLoadFunctionPrototype(*name, *function);
+          if (!t->ToObject(&code)) return t;
+        }
         set_target(Code::cast(code));
 #ifdef DEBUG
         TraceIC("KeyedLoadIC", name, state, target());
 #endif  // DEBUG
         return Accessors::FunctionGetPrototype(*object, 0);
       }
     }
 
     // Check if the name is trivially convertible to an index and get
     // the element or char if so.
@@ skipping 15 matching lines @@
         return ReferenceError("not_defined", name);
       }
     }
 
     if (FLAG_use_ic) {
       UpdateCaches(&lookup, state, object, name);
     }
 
     PropertyAttributes attr;
     if (lookup.IsProperty() && lookup.type() == INTERCEPTOR) {
+      Object* result;
+      { TryAllocation t = object->GetProperty(*object, &lookup, *name, &attr);
+        if (!t->ToObject(&result)) return t;
+      }
       // Get the property.
-      Object* result = object->GetProperty(*object, &lookup, *name, &attr);
-      if (result->IsFailure()) return result;
       // If the property is not present, check if we need to throw an
       // exception.
       if (attr == ABSENT && IsContextual(object)) {
         return ReferenceError("not_defined", name);
       }
       return result;
     }
 
     return object->GetProperty(*object, &lookup, *name, &attr);
   }
@@ skipping 541 matching lines @@
                   args.at<Object>(2));
 }
 
 
 Object* StoreIC_ArrayLength(Arguments args) {
   NoHandleAllocation nha;
 
   ASSERT(args.length() == 2);
   JSObject* receiver = JSObject::cast(args[0]);
   Object* len = args[1];
+  Object* result;
+  { TryAllocation t = receiver->SetElementsLength(len);
+    if (!t->ToObject(&result)) return t;
+  }
 
-  Object* result = receiver->SetElementsLength(len);
-  if (result->IsFailure()) return result;
   return len;
 }
 
 
 // Extend storage is called in a store inline cache when
 // it is necessary to extend the properties array of a
 // JSObject.
 Object* SharedStoreIC_ExtendStorage(Arguments args) {
   NoHandleAllocation na;
   ASSERT(args.length() == 3);
 
   // Convert the parameters
   JSObject* object = JSObject::cast(args[0]);
   Map* transition = Map::cast(args[1]);
   Object* value = args[2];
 
   // Check the object has run out out property space.
   ASSERT(object->HasFastProperties());
   ASSERT(object->map()->unused_property_fields() == 0);
 
   // Expand the properties array.
   FixedArray* old_storage = object->properties();
   int new_unused = transition->unused_property_fields();
+  Object* result;
+  { TryAllocation t = old_storage->CopySize(new_size);
+    if (!t->ToObject(&result)) return t;
+  }
   int new_size = old_storage->length() + new_unused + 1;
-  Object* result = old_storage->CopySize(new_size);
-  if (result->IsFailure()) return result;
   FixedArray* new_storage = FixedArray::cast(result);
   new_storage->set(old_storage->length(), value);
 
   // Set the new property value and do the map transition.
   object->set_properties(new_storage);
   object->set_map(transition);
 
   // Return the stored value.
   return value;
 }
@@ skipping 159 matching lines @@
 #undef ADDR
 };
 
 
 Address IC::AddressFromUtilityId(IC::UtilityId id) {
   return IC_utilities[id];
 }
 
 
 } }  // namespace v8::internal