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

src/builtins.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 170 matching lines @@
 
 BUILTIN(ArrayCodeGeneric) {
   Counters::array_function_runtime.Increment();
 
   JSArray* array;
   if (CalledAsConstructor()) {
     array = JSArray::cast(*args.receiver());
   } else {
     // Allocate the JS Array
     JSFunction* constructor =
+    Object* obj;
+    { TryAllocation t = Heap::AllocateJSObject(constructor);
+      if (!t->ToObject(&obj)) return t;
+    }
         Top::context()->global_context()->array_function();
-    Object* obj = Heap::AllocateJSObject(constructor);
-    if (obj->IsFailure()) return obj;
     array = JSArray::cast(obj);
   }
 
   // 'array' now contains the JSArray we should initialize.
   ASSERT(array->HasFastElements());
 
   // Optimize the case where there is one argument and the argument is a
   // small smi.
   if (args.length() == 2) {
     Object* obj = args[1];
     if (obj->IsSmi()) {
       int len = Smi::cast(obj)->value();
+        Object* obj;
+        { TryAllocation t = Heap::AllocateFixedArrayWithHoles(len);
+          if (!t->ToObject(&obj)) return t;
+        }
       if (len >= 0 && len < JSObject::kInitialMaxFastElementArray) {
-        Object* obj = Heap::AllocateFixedArrayWithHoles(len);
-        if (obj->IsFailure()) return obj;
         array->SetContent(FixedArray::cast(obj));
         return array;
       }
     }
+    { TryAllocation t = array->Initialize(0);
+      if (!t->ToObject(&obj)) return t;
+    }
     // Take the argument as the length.
-    obj = array->Initialize(0);
-    if (obj->IsFailure()) return obj;
     return array->SetElementsLength(args[1]);
   }
 
   // Optimize the case where there are no parameters passed.
   if (args.length() == 1) {
     return array->Initialize(JSArray::kPreallocatedArrayElements);
   }
 
   // Take the arguments as elements.
   int number_of_elements = args.length() - 1;
+  Object* obj;
+  { TryAllocation t = Heap::AllocateFixedArrayWithHoles(len->value());
+    if (!t->ToObject(&obj)) return t;
+  }
   Smi* len = Smi::FromInt(number_of_elements);
-  Object* obj = Heap::AllocateFixedArrayWithHoles(len->value());
-  if (obj->IsFailure()) return obj;
 
   AssertNoAllocation no_gc;
   FixedArray* elms = FixedArray::cast(obj);
   WriteBarrierMode mode = elms->GetWriteBarrierMode(no_gc);
   // Fill in the content
   for (int index = 0; index < number_of_elements; index++) {
     elms->set(index, args[index+1], mode);
   }
 
   // Set length and elements on the array.
   array->set_elements(FixedArray::cast(obj));
   array->set_length(len);
 
   return array;
 }
 
 
 MUST_USE_RESULT static Object* AllocateJSArray() {
   JSFunction* array_function =
+  Object* result;
+  { TryAllocation t = Heap::AllocateJSObject(array_function);
+    if (!t->ToObject(&result)) return t;
+  }
       Top::context()->global_context()->array_function();
-  Object* result = Heap::AllocateJSObject(array_function);
-  if (result->IsFailure()) return result;
   return result;
 }
 
 
+  Object* result;
+  { TryAllocation t = AllocateJSArray();
+    if (!t->ToObject(&result)) return t;
+  }
 MUST_USE_RESULT static Object* AllocateEmptyJSArray() {
-  Object* result = AllocateJSArray();
-  if (result->IsFailure()) return result;
   JSArray* result_array = JSArray::cast(result);
   result_array->set_length(Smi::FromInt(0));
   result_array->set_elements(Heap::empty_fixed_array());
   return result_array;
 }
 
 
 static void CopyElements(AssertNoAllocation* no_gc,
                          FixedArray* dst,
                          int dst_index,
@@ skipping 152 matching lines @@
     return Smi::FromInt(len);
   }
   // Currently fixed arrays cannot grow too big, so
   // we should never hit this case.
   ASSERT(to_add <= (Smi::kMaxValue - len));
 
   int new_length = len + to_add;
 
   if (new_length > elms->length()) {
     // New backing storage is needed.
+    Object* obj;
+    { TryAllocation t = Heap::AllocateUninitializedFixedArray(capacity);
+      if (!t->ToObject(&obj)) return t;
+    }
     int capacity = new_length + (new_length >> 1) + 16;
-    Object* obj = Heap::AllocateUninitializedFixedArray(capacity);
-    if (obj->IsFailure()) return obj;
     FixedArray* new_elms = FixedArray::cast(obj);
 
     AssertNoAllocation no_gc;
     if (len > 0) {
       CopyElements(&no_gc, new_elms, 0, elms, 0, len);
     }
     FillWithHoles(new_elms, new_length, capacity);
 
     elms = new_elms;
     array->set_elements(elms);
@@ skipping 35 matching lines @@
     return top;
   }
 
   top = array->GetPrototype()->GetElement(len - 1);
 
   return top;
 }
 
 
 BUILTIN(ArrayShift) {
+  Object* elms_obj;
+  { TryAllocation t = EnsureJSArrayWithWritableFastElements(receiver);
+    if (!t->ToObject(&elms_obj)) return t;
+  }
   Object* receiver = *args.receiver();
-  Object* elms_obj = EnsureJSArrayWithWritableFastElements(receiver);
-  if (elms_obj->IsFailure()) return elms_obj;
   if (elms_obj == NULL ||
       !IsJSArrayFastElementMovingAllowed(JSArray::cast(receiver))) {
     return CallJsBuiltin("ArrayShift", args);
   }
   FixedArray* elms = FixedArray::cast(elms_obj);
   JSArray* array = JSArray::cast(receiver);
   ASSERT(array->HasFastElements());
 
   int len = Smi::cast(array->length())->value();
   if (len == 0) return Heap::undefined_value();
@@ skipping 16 matching lines @@
   }
 
   // Set the length.
   array->set_length(Smi::FromInt(len - 1));
 
   return first;
 }
 
 
 BUILTIN(ArrayUnshift) {
+  Object* elms_obj;
+  { TryAllocation t = EnsureJSArrayWithWritableFastElements(receiver);
+    if (!t->ToObject(&elms_obj)) return t;
+  }
   Object* receiver = *args.receiver();
-  Object* elms_obj = EnsureJSArrayWithWritableFastElements(receiver);
-  if (elms_obj->IsFailure()) return elms_obj;
   if (elms_obj == NULL ||
       !IsJSArrayFastElementMovingAllowed(JSArray::cast(receiver))) {
     return CallJsBuiltin("ArrayUnshift", args);
   }
   FixedArray* elms = FixedArray::cast(elms_obj);
   JSArray* array = JSArray::cast(receiver);
   ASSERT(array->HasFastElements());
 
   int len = Smi::cast(array->length())->value();
   int to_add = args.length() - 1;
   int new_length = len + to_add;
   // Currently fixed arrays cannot grow too big, so
   // we should never hit this case.
   ASSERT(to_add <= (Smi::kMaxValue - len));
 
   if (new_length > elms->length()) {
     // New backing storage is needed.
+    Object* obj;
+    { TryAllocation t = Heap::AllocateUninitializedFixedArray(capacity);
+      if (!t->ToObject(&obj)) return t;
+    }
     int capacity = new_length + (new_length >> 1) + 16;
-    Object* obj = Heap::AllocateUninitializedFixedArray(capacity);
-    if (obj->IsFailure()) return obj;
     FixedArray* new_elms = FixedArray::cast(obj);
 
     AssertNoAllocation no_gc;
     if (len > 0) {
       CopyElements(&no_gc, new_elms, to_add, elms, 0, len);
     }
     FillWithHoles(new_elms, new_length, capacity);
 
     elms = new_elms;
     array->set_elements(elms);
   } else {
     AssertNoAllocation no_gc;
     MoveElements(&no_gc, elms, to_add, elms, 0, len);
   }
 
   // Add the provided values.
   AssertNoAllocation no_gc;
   WriteBarrierMode mode = elms->GetWriteBarrierMode(no_gc);
   for (int i = 0; i < to_add; i++) {
     elms->set(i, args[i + 1], mode);
   }
 
   // Set the length.
   array->set_length(Smi::FromInt(new_length));
   return Smi::FromInt(new_length);
 }
 
 
 BUILTIN(ArraySlice) {
+  Object* elms_obj;
+  { TryAllocation t = EnsureJSArrayWithWritableFastElements(receiver);
+    if (!t->ToObject(&elms_obj)) return t;
+  }
   Object* receiver = *args.receiver();
-  Object* elms_obj = EnsureJSArrayWithWritableFastElements(receiver);
-  if (elms_obj->IsFailure()) return elms_obj;
   if (elms_obj == NULL ||
       !IsJSArrayFastElementMovingAllowed(JSArray::cast(receiver))) {
     return CallJsBuiltin("ArraySlice", args);
   }
   FixedArray* elms = FixedArray::cast(elms_obj);
   JSArray* array = JSArray::cast(receiver);
   ASSERT(array->HasFastElements());
 
   int len = Smi::cast(array->length())->value();
 
@@ skipping 27 matching lines @@
 
   // ECMAScript 232, 3rd Edition, Section 15.4.4.10, step 8.
   int final = (relative_end < 0) ? Max(len + relative_end, 0)
                                  : Min(relative_end, len);
 
   // Calculate the length of result array.
   int result_len = final - k;
   if (result_len <= 0) {
     return AllocateEmptyJSArray();
   }
+  Object* result;
+  { TryAllocation t = AllocateJSArray();
+    if (!t->ToObject(&result)) return t;
+  }
 
-  Object* result = AllocateJSArray();
-  if (result->IsFailure()) return result;
   JSArray* result_array = JSArray::cast(result);
+  { TryAllocation t = Heap::AllocateUninitializedFixedArray(result_len);
+    if (!t->ToObject(&result)) return t;
+  }
 
-  result = Heap::AllocateUninitializedFixedArray(result_len);
-  if (result->IsFailure()) return result;
   FixedArray* result_elms = FixedArray::cast(result);
 
   AssertNoAllocation no_gc;
   CopyElements(&no_gc, result_elms, 0, elms, k, result_len);
 
   // Set elements.
   result_array->set_elements(result_elms);
 
   // Set the length.
   result_array->set_length(Smi::FromInt(result_len));
   return result_array;
 }
 
 
 BUILTIN(ArraySplice) {
+  Object* elms_obj;
+  { TryAllocation t = EnsureJSArrayWithWritableFastElements(receiver);
+    if (!t->ToObject(&elms_obj)) return t;
+  }
   Object* receiver = *args.receiver();
-  Object* elms_obj = EnsureJSArrayWithWritableFastElements(receiver);
-  if (elms_obj->IsFailure()) return elms_obj;
   if (elms_obj == NULL ||
       !IsJSArrayFastElementMovingAllowed(JSArray::cast(receiver))) {
     return CallJsBuiltin("ArraySplice", args);
   }
   FixedArray* elms = FixedArray::cast(elms_obj);
   JSArray* array = JSArray::cast(receiver);
   ASSERT(array->HasFastElements());
 
   int len = Smi::cast(array->length())->value();
 
@@ skipping 23 matching lines @@
     Object* arg2 = args[2];
     if (arg2->IsSmi()) {
       delete_count = Smi::cast(arg2)->value();
     } else {
       return CallJsBuiltin("ArraySplice", args);
     }
   }
   int actual_delete_count = Min(Max(delete_count, 0), len - actual_start);
 
   JSArray* result_array = NULL;
+    Object* result;
+    { TryAllocation t = AllocateEmptyJSArray();
+      if (!t->ToObject(&result)) return t;
+    }
   if (actual_delete_count == 0) {
-    Object* result = AllocateEmptyJSArray();
-    if (result->IsFailure()) return result;
     result_array = JSArray::cast(result);
   } else {
+    Object* result;
+    { TryAllocation t = AllocateJSArray();
+      if (!t->ToObject(&result)) return t;
+    }
     // Allocate result array.
-    Object* result = AllocateJSArray();
-    if (result->IsFailure()) return result;
     result_array = JSArray::cast(result);
+    { TryAllocation t =
+          Heap::AllocateUninitializedFixedArray(actual_delete_count);
+      if (!t->ToObject(&result)) return t;
+    }
 
-    result = Heap::AllocateUninitializedFixedArray(actual_delete_count);
-    if (result->IsFailure()) return result;
     FixedArray* result_elms = FixedArray::cast(result);
 
     AssertNoAllocation no_gc;
     // Fill newly created array.
     CopyElements(&no_gc,
                  result_elms, 0,
                  elms, actual_start,
                  actual_delete_count);
 
     // Set elements.
@@ skipping 31 matching lines @@
       FillWithHoles(elms, new_length, len);
     }
   } else if (item_count > actual_delete_count) {
     // Currently fixed arrays cannot grow too big, so
     // we should never hit this case.
     ASSERT((item_count - actual_delete_count) <= (Smi::kMaxValue - len));
 
     // Check if array need to grow.
     if (new_length > elms->length()) {
       // New backing storage is needed.
+      Object* obj;
+      { TryAllocation t = Heap::AllocateUninitializedFixedArray(capacity);
+        if (!t->ToObject(&obj)) return t;
+      }
       int capacity = new_length + (new_length >> 1) + 16;
-      Object* obj = Heap::AllocateUninitializedFixedArray(capacity);
-      if (obj->IsFailure()) return obj;
       FixedArray* new_elms = FixedArray::cast(obj);
 
       AssertNoAllocation no_gc;
       // Copy the part before actual_start as is.
       if (actual_start > 0) {
         CopyElements(&no_gc, new_elms, 0, elms, 0, actual_start);
       }
       const int to_copy = len - actual_delete_count - actual_start;
       if (to_copy > 0) {
         CopyElements(&no_gc,
@@ skipping 57 matching lines @@
 
     if (result_len > FixedArray::kMaxLength) {
       return CallJsBuiltin("ArrayConcat", args);
     }
   }
 
   if (result_len == 0) {
     return AllocateEmptyJSArray();
   }
 
+  Object* result;
+  { TryAllocation t = AllocateJSArray();
+    if (!t->ToObject(&result)) return t;
+  }
   // Allocate result.
-  Object* result = AllocateJSArray();
-  if (result->IsFailure()) return result;
   JSArray* result_array = JSArray::cast(result);
+  { TryAllocation t = Heap::AllocateUninitializedFixedArray(result_len);
+    if (!t->ToObject(&result)) return t;
+  }
 
-  result = Heap::AllocateUninitializedFixedArray(result_len);
-  if (result->IsFailure()) return result;
   FixedArray* result_elms = FixedArray::cast(result);
 
   // Copy data.
   AssertNoAllocation no_gc;
   int start_pos = 0;
   for (int i = 0; i < n_arguments; i++) {
     JSArray* array = JSArray::cast(args[i]);
     int len = Smi::cast(array->length())->value();
     if (len > 0) {
       FixedArray* elms = FixedArray::cast(array->elements());
@@ skipping 674 matching lines @@
       if (entry->contains(pc)) {
         return names_[i];
       }
     }
   }
   return NULL;
 }
 
 
 } }  // namespace v8::internal