Correctly OOM in the CEntryStub after retries.

This fixes a bug introduced in r20179.

R=jkummerow@chromium.org
BUG=356211
LOG=N

Review URL: https://codereview.chromium.org/213193011

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20292 ce2b1a6d-e550-0410-aec6-3dcde31c8c00

src/arm/code-stubs-arm.cc

@@ -1685,6 +1685,12 @@ void CEntryStub::Generate(MacroAssembler* masm) {
                true,
                true);
 
+  { FrameScope scope(masm, StackFrame::MANUAL);
+    __ PrepareCallCFunction(0, r0);
+    __ CallCFunction(
+        ExternalReference::out_of_memory_function(masm->isolate()), 0, 0);
+  }
+
   __ bind(&throw_termination_exception);
   __ ThrowUncatchable(r0);
 

src/arm64/code-stubs-arm64.cc

@@ -1764,6 +1764,11 @@ void CEntryStub::Generate(MacroAssembler* masm) {
   }
   __ SetStackPointer(jssp);
 
+  { FrameScope scope(masm, StackFrame::MANUAL);
+    __ CallCFunction(
+        ExternalReference::out_of_memory_function(masm->isolate()), 0, 0);
+  }
+
   // Throw exceptions.
   // If we throw an exception, we can end up re-entering CEntryStub before we
   // pop the exit frame, so need to ensure that x21-x23 contain GC-safe values

src/assembler.cc

@@ -1059,6 +1059,12 @@ ExternalReference ExternalReference::perform_gc_function(Isolate* isolate) {
 }
 
 
+ExternalReference ExternalReference::out_of_memory_function(Isolate* isolate) {
+  return
+      ExternalReference(Redirect(isolate, FUNCTION_ADDR(Runtime::OutOfMemory)));
+}
+
+
 ExternalReference ExternalReference::delete_handle_scope_extensions(
     Isolate* isolate) {
   return ExternalReference(Redirect(

src/assembler.h

@@ -748,6 +748,7 @@ class ExternalReference BASE_EMBEDDED {
       Isolate* isolate);
   static ExternalReference flush_icache_function(Isolate* isolate);
   static ExternalReference perform_gc_function(Isolate* isolate);
+  static ExternalReference out_of_memory_function(Isolate* isolate);
   static ExternalReference delete_handle_scope_extensions(Isolate* isolate);
 
   static ExternalReference get_date_field_function(Isolate* isolate);

src/ia32/code-stubs-ia32.cc

@@ -2751,6 +2751,12 @@ void CEntryStub::Generate(MacroAssembler* masm) {
                true,
                true);
 
+  { FrameScope scope(masm, StackFrame::MANUAL);
+    __ PrepareCallCFunction(0, eax);
+    __ CallCFunction(
+        ExternalReference::out_of_memory_function(masm->isolate()), 0);
+  }
+
   __ bind(&throw_termination_exception);
   __ ThrowUncatchable(eax);
 

src/mips/code-stubs-mips.cc

@@ -1794,6 +1794,12 @@ void CEntryStub::Generate(MacroAssembler* masm) {
                true,
                true);
 
+  { FrameScope scope(masm, StackFrame::MANUAL);
+    __ PrepareCallCFunction(0, v0);
+    __ CallCFunction(
+        ExternalReference::out_of_memory_function(masm->isolate()), 0);
+  }
+
   __ bind(&throw_termination_exception);
   __ ThrowUncatchable(v0);
 

src/runtime.cc

@@ -15175,4 +15175,9 @@ void Runtime::PerformGC(Object* result, Isolate* isolate) {
 }
 
 
+void Runtime::OutOfMemory() {
+  Heap::FatalProcessOutOfMemory("CALL_AND_RETRY_LAST", true);
+  UNREACHABLE();
+}
+
 } }  // namespace v8::internal

src/runtime.h

@@ -895,6 +895,7 @@ class Runtime : public AllStatic {
 
   // Helper functions used stubs.
   static void PerformGC(Object* result, Isolate* isolate);
+  static void OutOfMemory();
 
   // Used in runtime.cc and hydrogen's VisitArrayLiteral.
   static Handle<Object> CreateArrayLiteralBoilerplate(

src/serialize.cc

@@ -313,6 +313,11 @@ void ExternalReferenceTable::PopulateTable(Isolate* isolate) {
       RUNTIME_ENTRY,
       1,
       "Runtime::PerformGC");
+  // Runtime entries
+  Add(ExternalReference::out_of_memory_function(isolate).address(),
+      RUNTIME_ENTRY,
+      2,
+      "Runtime::OutOfMemory");
   Add(ExternalReference::delete_handle_scope_extensions(isolate).address(),
       RUNTIME_ENTRY,
       4,

src/x64/code-stubs-x64.cc

@@ -2603,6 +2603,12 @@ void CEntryStub::Generate(MacroAssembler* masm) {
                true,
                true);
 
+  { FrameScope scope(masm, StackFrame::MANUAL);
+    __ PrepareCallCFunction(0);
+    __ CallCFunction(
+        ExternalReference::out_of_memory_function(masm->isolate()), 0);
+  }
+
   __ bind(&throw_termination_exception);
   __ ThrowUncatchable(rax);
 

test/cctest/test-heap.cc

@@ -3889,4 +3889,28 @@ TEST(AddInstructionChangesNewSpacePromotion) {
   g->Call(global, 1, args1);
   heap->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
 }
-#endif
+
+
+void OnFatalErrorExpectOOM(const char* location, const char* message) {
+  // Exit with 0 if the location matches our expectation.
+  exit(strcmp(location, "CALL_AND_RETRY_LAST"));
+}
+
+
+TEST(CEntryStubOOM) {
+  i::FLAG_allow_natives_syntax = true;
+  CcTest::InitializeVM();
+  v8::HandleScope scope(CcTest::isolate());
+  v8::V8::SetFatalErrorHandler(OnFatalErrorExpectOOM);
+
+  CompileRun(
+      "%SetFlags('--gc-interval=1');"
+      "var a = [];"
+      "a.__proto__ = [];"
+      "a.unshift(1)");
+
+  // We should have run into an out of memory.
+  UNREACHABLE();
+}
+
+#endif  // DEBUG