If an allocation is so huge that we cannot code the size needed in the failur...

src/heap-inl.h

 // 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 165 matching lines @@
         }                                                                    \
         __object__ = FUNCTION_CALL;                                          \
         if (__object__->IsFailure()) {                                       \
           if (__object__->IsRetryAfterGC()) {                                \
             /* TODO(1181417): Fix this. */                                   \
             v8::internal::V8::FatalProcessOutOfMemory("CALL_HEAP_FUNCTION"); \
           }                                                                  \
           return Handle<TYPE>();                                             \
         }                                                                    \
       } else {                                                               \
+        if (__object__->IsOutOfMemoryFailure()) {                            \
+          v8::internal::V8::FatalProcessOutOfMemory("CALL_HEAP_FUNCTION");   \
+        }                                                                    \
         return Handle<TYPE>();                                               \
       }                                                                      \
     }                                                                        \
     return Handle<TYPE>(TYPE::cast(__object__));                             \
   } while (false)
 
 
 // Don't use the following names: __object__, __failure__.
 #define CALL_HEAP_FUNCTION_VOID(FUNCTION_CALL)                      \
   GC_GREEDY_CHECK();                                                \
   Object* __object__ = FUNCTION_CALL;                               \
   if (__object__->IsFailure()) {                                    \
     if (__object__->IsRetryAfterGC()) {                             \
       Failure* __failure__ = Failure::cast(__object__);             \
       if (!Heap::CollectGarbage(__failure__->requested(),           \
                                 __failure__->allocation_space())) { \
          /* TODO(1181417): Fix this. */                             \
          V8::FatalProcessOutOfMemory("Handles");                    \
       }                                                             \
       __object__ = FUNCTION_CALL;                                   \
       if (__object__->IsFailure()) {                                \
         if (__object__->IsRetryAfterGC()) {                         \
            /* TODO(1181417): Fix this. */                           \
            V8::FatalProcessOutOfMemory("Handles");                  \
         }                                                           \
         return;                                                     \
       }                                                             \
     } else {                                                        \
-      return;                                                       \
+      if (__object__->IsOutOfMemoryFailure()) {                     \
+         V8::FatalProcessOutOfMemory("Handles");                    \
+      }                                                             \
+      UNREACHABLE();                                                \
     }                                                               \
   }
 
 
 #ifdef DEBUG
 
 inline bool Heap::allow_allocation(bool new_state) {
   bool old = allocation_allowed_;
   allocation_allowed_ = new_state;
   return old;
 }
 
 #endif
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_HEAP_INL_H_