Revert "Unification: introduce ExternalReference::pending_exception_address()."

src/x64/code-stubs-x64.cc

 // Copyright 2011 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 2108 matching lines @@
   NearLabel failure;
   __ cmpl(rax, Immediate(NativeRegExpMacroAssembler::FAILURE));
   __ j(equal, &failure);
   __ cmpl(rax, Immediate(NativeRegExpMacroAssembler::EXCEPTION));
   // If not exception it can only be retry. Handle that in the runtime system.
   __ j(not_equal, &runtime);
   // Result must now be exception. If there is no pending exception already a
   // stack overflow (on the backtrack stack) was detected in RegExp code but
   // haven't created the exception yet. Handle that in the runtime system.
   // TODO(592): Rerunning the RegExp to get the stack overflow exception.
-  __ movq(kScratchRegister, ExternalReference::pending_exception_address());
+  ExternalReference pending_exception_address(Top::k_pending_exception_address);
+  __ movq(kScratchRegister, pending_exception_address);
   __ Cmp(kScratchRegister, Factory::the_hole_value());
   __ j(equal, &runtime);
   __ bind(&failure);
   // For failure and exception return null.
   __ Move(rax, Factory::null_value());
   __ ret(4 * kPointerSize);
 
   // Load RegExp data.
   __ bind(&success);
   __ movq(rax, Operand(rsp, kJSRegExpOffset));
@@ skipping 737 matching lines @@
   STATIC_ASSERT(Failure::RETRY_AFTER_GC == 0);
   __ testl(rax, Immediate(((1 << kFailureTypeTagSize) - 1) << kFailureTagSize));
   __ j(zero, &retry);
 
   // Special handling of out of memory exceptions.
   __ movq(kScratchRegister, Failure::OutOfMemoryException(), RelocInfo::NONE);
   __ cmpq(rax, kScratchRegister);
   __ j(equal, throw_out_of_memory_exception);
 
   // Retrieve the pending exception and clear the variable.
-  __ movq(kScratchRegister, ExternalReference::pending_exception_address());
+  ExternalReference pending_exception_address(Top::k_pending_exception_address);
+  __ movq(kScratchRegister, pending_exception_address);
   __ movq(rax, Operand(kScratchRegister, 0));
   __ movq(rdx, ExternalReference::the_hole_value_location());
   __ movq(rdx, Operand(rdx, 0));
   __ movq(Operand(kScratchRegister, 0), rdx);
 
   // Special handling of termination exceptions which are uncatchable
   // by javascript code.
   __ CompareRoot(rax, Heap::kTerminationExceptionRootIndex);
   __ j(equal, throw_termination_exception);
 
@@ skipping 29 matching lines @@
   __ movq(kScratchRegister, handler_address);
   __ pop(Operand(kScratchRegister, 0));
 
   if (type == OUT_OF_MEMORY) {
     // Set external caught exception to false.
     ExternalReference external_caught(Top::k_external_caught_exception_address);
     __ movq(rax, Immediate(false));
     __ store_rax(external_caught);
 
     // Set pending exception and rax to out of memory exception.
+    ExternalReference pending_exception(Top::k_pending_exception_address);
     __ movq(rax, Failure::OutOfMemoryException(), RelocInfo::NONE);
-    __ store_rax(ExternalReference::pending_exception_address());
+    __ store_rax(pending_exception);
   }
 
   // Clear the context pointer.
   __ Set(rsi, 0);
 
   // Restore registers from handler.
   STATIC_ASSERT(StackHandlerConstants::kNextOffset + kPointerSize ==
             StackHandlerConstants::kFPOffset);
   __ pop(rbp);  // FP
   STATIC_ASSERT(StackHandlerConstants::kFPOffset + kPointerSize ==
@@ skipping 132 matching lines @@
   __ movq(rax, rbp);
   __ store_rax(js_entry_sp);
   __ bind(&not_outermost_js);
 #endif
 
   // Call a faked try-block that does the invoke.
   __ call(&invoke);
 
   // Caught exception: Store result (exception) in the pending
   // exception field in the JSEnv and return a failure sentinel.
-  __ store_rax(ExternalReference::pending_exception_address());
+  ExternalReference pending_exception(Top::k_pending_exception_address);
+  __ store_rax(pending_exception);
   __ movq(rax, Failure::Exception(), RelocInfo::NONE);
   __ jmp(&exit);
 
   // Invoke: Link this frame into the handler chain.
   __ bind(&invoke);
   __ PushTryHandler(IN_JS_ENTRY, JS_ENTRY_HANDLER);
 
   // Clear any pending exceptions.
   __ load_rax(ExternalReference::the_hole_value_location());
-  __ store_rax(ExternalReference::pending_exception_address());
+  __ store_rax(pending_exception);
 
   // Fake a receiver (NULL).
   __ push(Immediate(0));  // receiver
 
   // Invoke the function by calling through JS entry trampoline
   // builtin and pop the faked function when we return. We load the address
   // from an external reference instead of inlining the call target address
   // directly in the code, because the builtin stubs may not have been
   // generated yet at the time this code is generated.
   if (is_construct) {
@@ skipping 1274 matching lines @@
 
   // Do a tail call to the rewritten stub.
   __ jmp(rdi);
 }
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64