Revert "Remove Failure::OutOfMemory propagation and V8::IgnoreOutOfMemoryException."

src/arm64/code-stubs-arm64.cc

 // Copyright 2013 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 1387 matching lines @@
 }
 
 
 void CodeStub::GenerateFPStubs(Isolate* isolate) {
   // Floating-point code doesn't get special handling in ARM64, so there's
   // nothing to do here.
   USE(isolate);
 }
 
 
+static void JumpIfOOM(MacroAssembler* masm,
+                      Register value,
+                      Register scratch,
+                      Label* oom_label) {
+  STATIC_ASSERT(Failure::OUT_OF_MEMORY_EXCEPTION == 3);
+  STATIC_ASSERT(kFailureTag == 3);
+  __ And(scratch, value, 0xf);
+  __ Cmp(scratch, 0xf);
+  __ B(eq, oom_label);
+}
+
+
 bool CEntryStub::NeedsImmovableCode() {
   // CEntryStub stores the return address on the stack before calling into
   // C++ code. In some cases, the VM accesses this address, but it is not used
   // when the C++ code returns to the stub because LR holds the return address
   // in AAPCS64. If the stub is moved (perhaps during a GC), we could end up
   // returning to dead code.
   // TODO(jbramley): Whilst this is the only analysis that makes sense, I can't
   // find any comment to confirm this, and I don't hit any crashes whatever
   // this function returns. The anaylsis should be properly confirmed.
   return true;
 }
 
 
 void CEntryStub::GenerateAheadOfTime(Isolate* isolate) {
   CEntryStub stub(1, kDontSaveFPRegs);
   stub.GetCode(isolate);
   CEntryStub stub_fp(1, kSaveFPRegs);
   stub_fp.GetCode(isolate);
 }
 
 
 void CEntryStub::GenerateCore(MacroAssembler* masm,
                               Label* throw_normal,
                               Label* throw_termination,
+                              Label* throw_out_of_memory,
                               bool do_gc,
                               bool always_allocate) {
   // x0  : Result parameter for PerformGC, if do_gc is true.
   // x21 : argv
   // x22 : argc
   // x23 : target
   //
   // The stack (on entry) holds the arguments and the receiver, with the
   // receiver at the highest address:
   //
@@ skipping 127 matching lines @@
   //  x0    result      The return code from the call, including the failure
   //                    code and details.
   //  x21   argv
   //  x22   argc
   //  x23   target
   // Refer to the Failure class for details of the bit layout.
   STATIC_ASSERT(Failure::RETRY_AFTER_GC == 0);
   __ Tst(result, kFailureTypeTagMask << kFailureTagSize);
   __ B(eq, &retry);   // RETRY_AFTER_GC
 
+  // Special handling of out-of-memory exceptions: Pass the failure result,
+  // rather than the exception descriptor.
+  JumpIfOOM(masm, result, x10, throw_out_of_memory);
+
   // Retrieve the pending exception.
   const Register& exception = result;
   const Register& exception_address = x11;
   __ Mov(exception_address,
          Operand(ExternalReference(Isolate::kPendingExceptionAddress,
                                    isolate)));
   __ Ldr(exception, MemOperand(exception_address));
 
+  // See if we just retrieved an OOM exception.
+  JumpIfOOM(masm, exception, x10, throw_out_of_memory);
+
   // Clear the pending exception.
   __ Mov(x10, Operand(isolate->factory()->the_hole_value()));
   __ Str(x10, MemOperand(exception_address));
 
   //  x0    exception   The exception descriptor.
   //  x21   argv
   //  x22   argc
   //  x23   target
 
   // Special handling of termination exceptions, which are uncatchable by
@@ skipping 73 matching lines @@
   // could be pushed onto the stack by called stubs and functions, and on the
   // stack they can confuse the GC. However, we're only calling C functions
   // which can push arbitrary data onto the stack anyway, and so the GC won't
   // examine that part of the stack.
   __ Mov(argc, argc_input);
   __ Mov(target, target_input);
   __ Mov(argv, temp_argv);
 
   Label throw_normal;
   Label throw_termination;
+  Label throw_out_of_memory;
 
   // Call the runtime function.
   GenerateCore(masm,
                &throw_normal,
                &throw_termination,
+               &throw_out_of_memory,
                false,
                false);
 
   // If successful, the previous GenerateCore will have returned to the
   // calling code. Otherwise, we fall through into the following.
 
   // Do space-specific GC and retry runtime call.
   GenerateCore(masm,
                &throw_normal,
                &throw_termination,
+               &throw_out_of_memory,
                true,
                false);
 
   // Do full GC and retry runtime call one final time.
   __ Mov(x0, reinterpret_cast<uint64_t>(Failure::InternalError()));
   GenerateCore(masm,
                &throw_normal,
                &throw_termination,
+               &throw_out_of_memory,
                true,
                true);
 
   // We didn't execute a return case, so the stack frame hasn't been updated
   // (except for the return address slot). However, we don't need to initialize
   // jssp because the throw method will immediately overwrite it when it
   // unwinds the stack.
   if (__ emit_debug_code()) {
     __ Mov(jssp, kDebugZapValue);
   }
   __ SetStackPointer(jssp);
 
   // 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
   // here.
+  __ Bind(&throw_out_of_memory);
+  ASM_LOCATION("Throw out of memory");
+  __ Mov(argv, 0);
+  __ Mov(argc, 0);
+  __ Mov(target, 0);
+  // Set external caught exception to false.
+  Isolate* isolate = masm->isolate();
+  __ Mov(x2, Operand(ExternalReference(Isolate::kExternalCaughtExceptionAddress,
+                                       isolate)));
+  __ Str(xzr, MemOperand(x2));
+
+  // Set pending exception and x0 to out of memory exception.
+  Label already_have_failure;
+  JumpIfOOM(masm, x0, x10, &already_have_failure);
+  Failure* out_of_memory = Failure::OutOfMemoryException(0x1);
+  __ Mov(x0, Operand(reinterpret_cast<uint64_t>(out_of_memory)));
+  __ Bind(&already_have_failure);
+  __ Mov(x2, Operand(ExternalReference(Isolate::kPendingExceptionAddress,
+                                       isolate)));
+  __ Str(x0, MemOperand(x2));
+  // Fall through to the next label.
 
   __ Bind(&throw_termination);
   ASM_LOCATION("Throw termination");
   __ Mov(argv, 0);
   __ Mov(argc, 0);
   __ Mov(target, 0);
   __ ThrowUncatchable(x0, x10, x11, x12, x13);
 
   __ Bind(&throw_normal);
   ASM_LOCATION("Throw normal");
@@ skipping 3946 matching lines @@
                               MemOperand(fp, 6 * kPointerSize),
                               NULL);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM64