Stop creating dummy call frames when calling out to C functions

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 856 matching lines @@
 // Notes on stack frame walking:
 //
 // The sampling profiler will collect up to Sample::kNumStackFrames stack frames
 // The stack frame walking code uses the frame pointer to traverse the stack.
 // If the VM is compiled without frame pointers (which is the default on
 // recent GCC versions with optimizing enabled) the stack walking code may
 // fail (sometimes leading to a crash).
 //
 class ProfilerSampleStackWalker : public ValueObject {
  public:
-  ProfilerSampleStackWalker(Sample* sample,
+  ProfilerSampleStackWalker(Heap* heap,
+                            Sample* sample,
                             uword stack_lower,
                             uword stack_upper,
                             uword pc,
                             uword fp,
                             uword sp)
-      : sample_(sample),
+      : heap_(heap),
+        sample_(sample),
         stack_upper_(stack_upper),
         original_pc_(pc),
         original_fp_(fp),
         original_sp_(sp),
         lower_bound_(stack_lower) {
     ASSERT(sample_ != NULL);
   }
 
   int walk() {
     const intptr_t kMaxStep = 0x1000;  // 4K.
@@ skipping 17 matching lines @@
       // 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
       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) {
+      bool contained = heap_->Contains(pc);
+      bool code_contained = heap_->CodeContains(pc);
+      if (contained != code_contained) {

[siva, 2014/02/27 00:00:26]

Doesn't short circuit when it is not contained in the heap
if (heap_->Contains(pc) && !heap_->CodeContains(pc)) {
  ...
  ...
}
would not call CodeContains(pc) for values that are not in the heap.
The reverse can never be true right, i.e CodeContains returns true and Contains
false.

[Cutch, 2014/02/27 15:52:37]

Done.

+        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_);
+      }
+      ASSERT(contained == code_contained);
+    }
+  }
+#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;
   }
 
+  Heap* heap_;
   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 12 matching lines @@
   }
   Sample* sample = sample_buffer->ReserveSample();
   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);
+  ProfilerSampleStackWalker stackWalker(isolate->heap(), sample, stack_lower,
+                                        stack_upper, state.pc, state.fp,
+                                        state.sp);
   stackWalker.walk();
 }
 
 
 }  // namespace dart