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

src/execution.cc

 // Copyright 2014 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/execution.h"
 
 #include "src/bootstrapper.h"
 #include "src/codegen.h"
 #include "src/compiler-dispatcher/optimizing-compile-dispatcher.h"
 #include "src/debug/debug.h"
@@ skipping 42 matching lines @@
 }
 
 
 namespace {
 
 MUST_USE_RESULT MaybeHandle<Object> Invoke(
     Isolate* isolate, bool is_construct, Handle<Object> target,
     Handle<Object> receiver, int argc, Handle<Object> args[],
     Handle<Object> new_target, Execution::MessageHandling message_handling) {
   DCHECK(!receiver->IsJSGlobalObject());
+#if DEBUG
+  // Assume that any JS call can allocate.
+  if (FLAG_zap_cpp_pointers) ZapHeapPointersInCppFrames(isolate);
+#endif
 
 #ifdef USE_SIMULATOR
   // Simulators use separate stacks for C++ and JS. JS stack overflow checks
   // are performed whenever a JS function is called. However, it can be the case
   // that the C++ stack grows faster than the JS stack, resulting in an overflow
   // there. Add a check here to make that less likely.
   StackLimitCheck check(isolate);
   if (check.HasOverflowed()) {
     isolate->StackOverflow();
     if (message_handling == Execution::MessageHandling::kReport) {
@@ skipping 338 matching lines @@
   set_climit(kIllegalLimit);
   postpone_interrupts_ = NULL;
   interrupt_flags_ = 0;
 }
 
 
 bool StackGuard::ThreadLocal::Initialize(Isolate* isolate) {
   bool should_set_stack_limits = false;
   if (real_climit_ == kIllegalLimit) {
     const uintptr_t kLimitSize = FLAG_stack_size * KB;
-    DCHECK(GetCurrentStackPosition() > kLimitSize);
-    uintptr_t limit = GetCurrentStackPosition() - kLimitSize;
+    uintptr_t current_stack_position = GetCurrentStackPosition();
+#if DEBUG
+    DCHECK(current_stack_position > kLimitSize);
+    stack_base_position_ = current_stack_position;
+#endif
+    uintptr_t limit = current_stack_position - kLimitSize;
     real_jslimit_ = SimulatorStack::JsLimitFromCLimit(isolate, limit);
     set_jslimit(SimulatorStack::JsLimitFromCLimit(isolate, limit));
     real_climit_ = limit;
     set_climit(limit);
     should_set_stack_limits = true;
   }
   postpone_interrupts_ = NULL;
   interrupt_flags_ = 0;
   return should_set_stack_limits;
 }
@@ skipping 61 matching lines @@
 
   isolate_->counters()->stack_interrupts()->Increment();
   isolate_->counters()->runtime_profiler_ticks()->Increment();
   isolate_->runtime_profiler()->MarkCandidatesForOptimization();
 
   return isolate_->heap()->undefined_value();
 }
 
 }  // namespace internal
 }  // namespace v8