Turn stack walking verification into a flag

runtime/vm/profiler.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "platform/utils.h"
 
 #include "vm/allocation.h"
 #include "vm/atomic.h"
 #include "vm/code_patcher.h"
 #include "vm/isolate.h"
@@ skipping 15 matching lines @@
 #else
   DEFINE_FLAG(bool, profile, true, "Enable Sampling Profiler");
 #endif
 DEFINE_FLAG(bool, trace_profiled_isolates, false, "Trace profiled isolates.");
 DEFINE_FLAG(charp, profile_dir, NULL,
             "Enable writing profile data into specified directory.");
 DEFINE_FLAG(int, profile_period, 1000,
             "Time between profiler samples in microseconds. Minimum 250.");
 DEFINE_FLAG(int, profile_depth, 8,
             "Maximum number stack frames walked. Minimum 1. Maximum 255.");
+DEFINE_FLAG(bool, profile_verify_stack_walk, false,
+            "Verify instruction addresses while walking the stack.");
 
 bool Profiler::initialized_ = false;
 SampleBuffer* Profiler::sample_buffer_ = NULL;
 
 void Profiler::InitOnce() {
   // Place some sane restrictions on user controlled flags.
   SetSamplePeriod(FLAG_profile_period);
   SetSampleDepth(FLAG_profile_depth);
   if (!FLAG_profile) {
     return;
@@ skipping 836 matching lines @@
                             uword sp)
       : sample_(sample),
         stack_upper_(stack_upper),
         original_pc_(pc),
         original_fp_(fp),
         original_sp_(sp),
         lower_bound_(stack_lower) {
     ASSERT(sample_ != NULL);
   }
 
-#if defined(DEBUG_STACK_WALK)
-  void set_heap(Heap* heap) {
-    heap_ = heap;
-  }
-#endif
-
-  int walk() {
+  int walk(Heap* heap) {
     const intptr_t kMaxStep = 0x1000;  // 4K.
     const bool kWalkStack = true;  // Walk the stack.
     // Always store the exclusive PC.
     sample_->SetAt(0, original_pc_);
     if (!kWalkStack) {
       // Not walking the stack, only took exclusive sample.
       return 1;
     }
     uword* pc = reinterpret_cast<uword*>(original_pc_);
     uword* fp = reinterpret_cast<uword*>(original_fp_);
     uword* previous_fp = fp;
     if (original_sp_ > original_fp_) {
       // Stack pointer should not be above frame pointer.
       return 1;
     }
     intptr_t gap = original_fp_ - original_sp_;
     if (gap >= kMaxStep) {
       // Gap between frame pointer and stack pointer is
       // too large.
       return 1;
     }
     if (original_sp_ < lower_bound_) {
       // The stack pointer gives us a better lower bound than
       // the isolates stack limit.
       lower_bound_ = original_sp_;
     }
     int i = 0;
     for (; i < FLAG_profile_depth; i++) {
-#if defined(DEBUG_STACK_WALK)
-      VerifyCodeAddress(i, reinterpret_cast<uword>(pc));
-#endif
+      if (FLAG_profile_verify_stack_walk) {
+        VerifyCodeAddress(heap, i, reinterpret_cast<uword>(pc));
+      }
       sample_->SetAt(i, reinterpret_cast<uword>(pc));
       if (!ValidFramePointer(fp)) {
         return i + 1;
       }
       pc = CallerPC(fp);
       previous_fp = fp;
       fp = CallerFP(fp);
       intptr_t step = fp - previous_fp;
       if ((step >= kMaxStep) || (fp <= previous_fp) || !ValidFramePointer(fp)) {
         // Frame pointer step is too large.
         // Frame pointer did not move to a higher address.
         // Frame pointer is outside of isolate stack bounds.
         return i + 1;
       }
       // Move the lower bound up.
       lower_bound_ = reinterpret_cast<uword>(fp);
     }
     return i;
   }
 
  private:
-#if defined(DEBUG_STACK_WALK)
-  void VerifyCodeAddress(int i, uword pc) {
-    if (heap_ != NULL) {
-      if (heap_->Contains(pc) && !heap_->CodeContains(pc)) {
+  void VerifyCodeAddress(Heap* heap, int i, uword pc) {
+    if (heap != NULL) {
+      if (heap->Contains(pc) && !heap->CodeContains(pc)) {
         for (int j = 0; j < i; j++) {
           OS::Print("%d %" Px "\n", j, sample_->At(j));
         }
         OS::Print("%d %" Px " <--\n", i, pc);
         OS::Print("---ASSERT-FAILED---\n");
         OS::Print("%" Px " %" Px "\n", original_pc_, original_fp_);
         UNREACHABLE();
       }
     }
   }
-#endif
 
   uword* CallerPC(uword* fp) const {
     ASSERT(fp != NULL);
     return reinterpret_cast<uword*>(*(fp + kSavedCallerPcSlotFromFp));
   }
 
   uword* CallerFP(uword* fp) const {
     ASSERT(fp != NULL);
     return reinterpret_cast<uword*>(*(fp + kSavedCallerFpSlotFromFp));
   }
 
   bool ValidFramePointer(uword* fp) const {
     if (fp == NULL) {
       return false;
     }
     uword cursor = reinterpret_cast<uword>(fp);
     cursor += sizeof(fp);
     bool r = cursor >= lower_bound_ && cursor < stack_upper_;
     return r;
   }
 
-#if defined(DEBUG_STACK_WALK)
-  Heap* heap_;
-#endif
+
   Sample* sample_;
   const uword stack_upper_;
   const uword original_pc_;
   const uword original_fp_;
   const uword original_sp_;
   uword lower_bound_;
 };
 
 void Profiler::RecordSampleInterruptCallback(
     const InterruptedThreadState& state,
@@ skipping 14 matching lines @@
   sample->Init(isolate, OS::GetCurrentTimeMicros(), state.tid);
   uword stack_lower = 0;
   uword stack_upper = 0;
   isolate->GetStackBounds(&stack_lower, &stack_upper);
   if ((stack_lower == 0) || (stack_upper == 0)) {
     stack_lower = 0;
     stack_upper = 0;
   }
   ProfilerSampleStackWalker stackWalker(sample, stack_lower, stack_upper,
                                         state.pc, state.fp, state.sp);
-#if defined(DEBUG_STACK_WALK)
-  stackWalker.set_heap(isolate->heap());
-#endif
-  stackWalker.walk();
+  stackWalker.walk(isolate->heap());
 }
 
 
 }  // namespace dart