Introduce --zap-cpp-pointers (off by default)

src/regexp/regexp-macro-assembler.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/regexp/regexp-macro-assembler.h"
 
 #include "src/assembler.h"
 #include "src/isolate-inl.h"
 #include "src/regexp/regexp-stack.h"
 #include "src/simulator.h"
@@ skipping 147 matching lines @@
 
 int NativeRegExpMacroAssembler::CheckStackGuardState(
     Isolate* isolate, int start_index, bool is_direct_call,
     Address* return_address, Code* re_code, String** subject,
     const byte** input_start, const byte** input_end) {
   DCHECK(re_code->instruction_start() <= *return_address);
   DCHECK(*return_address <= re_code->instruction_end());
   int return_value = 0;
   // Prepare for possible GC.
   HandleScope handles(isolate);
+  intptr_t return_address_offset =
+      *return_address - re_code->instruction_start();
   Handle<Code> code_handle(re_code);
   Handle<String> subject_handle(*subject);
   bool is_one_byte = subject_handle->IsOneByteRepresentationUnderneath();
+  intptr_t byte_length = *input_end - *input_start;
 
   StackLimitCheck check(isolate);
   bool js_has_overflowed = check.JsHasOverflowed();
 
   if (is_direct_call) {
     // Direct calls from JavaScript can be interrupted in two ways:
     // 1. A real stack overflow, in which case we let the caller throw the
     //    exception.
     // 2. The stack guard was used to interrupt execution for another purpose,
     //    forcing the call through the runtime system.
     return_value = js_has_overflowed ? EXCEPTION : RETRY;
   } else if (js_has_overflowed) {
     isolate->StackOverflow();
     return_value = EXCEPTION;
   } else {
     Object* result = isolate->stack_guard()->HandleInterrupts();
     if (result->IsException(isolate)) return_value = EXCEPTION;
   }
 
   DisallowHeapAllocation no_gc;
 
-  if (*code_handle != re_code) {  // Return address no longer valid
-    intptr_t delta = code_handle->address() - re_code->address();
-    // Overwrite the return address on the stack.
-    *return_address += delta;
-  }
+  // Fix up the return address (it might be no longer valid after GC).
+  *return_address = code_handle->instruction_start() + return_address_offset;
 
   // If we continue, we need to update the subject string addresses.
   if (return_value == 0) {
     // String encoding might have changed.
     if (subject_handle->IsOneByteRepresentationUnderneath() != is_one_byte) {
       // If we changed between an LATIN1 and an UC16 string, the specialized
       // code cannot be used, and we need to restart regexp matching from
       // scratch (including, potentially, compiling a new version of the code).
       return_value = RETRY;
     } else {
       *subject = *subject_handle;
-      intptr_t byte_length = *input_end - *input_start;
       *input_start = StringCharacterPosition(*subject, start_index);
       *input_end = *input_start + byte_length;
     }
   }
   return return_value;
 }
 
 
 NativeRegExpMacroAssembler::Result NativeRegExpMacroAssembler::Match(
     Handle<Code> regexp_code,
@@ skipping 138 matching lines @@
   }
   *stack_base = new_stack_base;
   intptr_t stack_content_size = old_stack_base - stack_pointer;
   return new_stack_base - stack_content_size;
 }
 
 #endif  // V8_INTERPRETED_REGEXP
 
 }  // namespace internal
 }  // namespace v8