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

src/accessors.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 423 matching lines @@
 
 //
 // Accessors::FunctionPrototype
 //
 
 
 Object* Accessors::FunctionGetPrototype(Object* object, void*) {
   bool found_it = false;
   JSFunction* function = FindInPrototypeChain<JSFunction>(object, &found_it);
   if (!found_it) return Heap::undefined_value();
+    Object* prototype;
+    { TryAllocation t = Heap::AllocateFunctionPrototype(function);
+      if (!t->ToObject(&prototype)) return t;
+    }
   if (!function->has_prototype()) {
-    Object* prototype = Heap::AllocateFunctionPrototype(function);
-    if (prototype->IsFailure()) return prototype;
-    Object* result = function->SetPrototype(prototype);
-    if (result->IsFailure()) return result;
+    Object* result;
+    { TryAllocation t = function->SetPrototype(prototype);
+      if (!t->ToObject(&result)) return t;
+    }
   }
   return function->prototype();
 }
 
 
 Object* Accessors::FunctionSetPrototype(JSObject* object,
                                         Object* value,
                                         void*) {
   bool found_it = false;
   JSFunction* function = FindInPrototypeChain<JSFunction>(object, &found_it);
   if (!found_it) return Heap::undefined_value();
   if (function->has_initial_map()) {
     // If the function has allocated the initial map
+    Object* new_map;
+    { TryAllocation t = function->initial_map()->CopyDropTransitions();
+      if (!t->ToObject(&new_map)) return t;
+    }
     // replace it with a copy containing the new prototype.
-    Object* new_map = function->initial_map()->CopyDropTransitions();
-    if (new_map->IsFailure()) return new_map;
     function->set_initial_map(Map::cast(new_map));
+  Object* prototype;
+  { TryAllocation t = function->SetPrototype(value);
+    if (!t->ToObject(&prototype)) return t;
   }
-  Object* prototype = function->SetPrototype(value);
-  if (prototype->IsFailure()) return prototype;
+  }
   ASSERT(function->prototype() == value);
   return function;
 }
 
 
 const AccessorDescriptor Accessors::FunctionPrototype = {
   FunctionGetPrototype,
   FunctionSetPrototype,
   0
 };
@@ skipping 173 matching lines @@
 }
 
 
 const AccessorDescriptor Accessors::ObjectPrototype = {
   ObjectGetPrototype,
   ObjectSetPrototype,
   0
 };
 
 } }  // namespace v8::internal