Fix memory leak in CPU Profile page

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/address_sanitizer.h"
 #include "platform/memory_sanitizer.h"
 #include "platform/utils.h"
 
 #include "vm/allocation.h"
 #include "vm/atomic.h"
@@ skipping 28 matching lines @@
 DEFINE_FLAG(bool, profile_vm, true,
             "Always collect native stack traces.");
 #else
 DEFINE_FLAG(bool, profile_vm, false,
             "Always collect native stack traces.");
 #endif
 
 bool Profiler::initialized_ = false;
 SampleBuffer* Profiler::sample_buffer_ = NULL;
 
+static intptr_t NumberOfFramesToCollect() {
+  if (FLAG_profile_depth <= 0) {
+    return 0;
+  }
+  // Subtract to reserve space for the possible missing frame.
+  return FLAG_profile_depth - 1;
+}
+
 void Profiler::InitOnce() {
   // Place some sane restrictions on user controlled flags.
   SetSamplePeriod(FLAG_profile_period);
   SetSampleDepth(FLAG_profile_depth);
   Sample::InitOnce();
   if (!FLAG_profile) {
     return;
   }
   ASSERT(!initialized_);
   sample_buffer_ = new SampleBuffer();
   NativeSymbolResolver::InitOnce();
   ThreadInterrupter::SetInterruptPeriod(FLAG_profile_period);
   ThreadInterrupter::Startup();
   initialized_ = true;
 }
 
 
 void Profiler::Shutdown() {
   if (!FLAG_profile) {
     return;
   }
   ASSERT(initialized_);
   ThreadInterrupter::Shutdown();
   NativeSymbolResolver::ShutdownOnce();
 }
 
 
 void Profiler::SetSampleDepth(intptr_t depth) {
-  const int kMinimumDepth = 1;
+  const int kMinimumDepth = 2;
   const int kMaximumDepth = 255;
   if (depth < kMinimumDepth) {
     FLAG_profile_depth = kMinimumDepth;
   } else if (depth > kMaximumDepth) {
     FLAG_profile_depth = kMaximumDepth;
   } else {
     FLAG_profile_depth = depth;
   }
 }
 
@@ skipping 118 matching lines @@
     ThreadInterrupter::WakeUp();
   }
 }
 
 
 intptr_t Sample::pcs_length_ = 0;
 intptr_t Sample::instance_size_ = 0;
 
 
 void Sample::InitOnce() {
-  ASSERT(FLAG_profile_depth >= 1);
+  ASSERT(FLAG_profile_depth >= 2);
   pcs_length_ = FLAG_profile_depth;
   instance_size_ =
       sizeof(Sample) + (sizeof(uword) * pcs_length_);  // NOLINT.
 }
 
 
 uword* Sample::GetPCArray() const {
   return reinterpret_cast<uword*>(
         reinterpret_cast<uintptr_t>(this) + sizeof(*this));
 }
@@ skipping 358 matching lines @@
     // Mark that this sample was collected from an exit frame.
     sample_->set_exit_frame_sample(true);
   }
 
   void walk() {
     intptr_t frame_index = 0;
     StackFrame* frame = frame_iterator_.NextFrame();
     while (frame != NULL) {
       sample_->SetAt(frame_index, frame->pc());
       frame_index++;
-      if (frame_index >= FLAG_profile_depth) {
+      if (frame_index >= NumberOfFramesToCollect()) {
+        sample_->set_truncated_trace(true);
         break;
       }
       frame = frame_iterator_.NextFrame();
     }
   }
 
  private:
   Sample* sample_;
   DartFrameIterator frame_iterator_;
 };
@@ skipping 29 matching lines @@
     if (StubCode::InInvocationStubForIsolate(isolate_, return_pc)) {
       // Edge case- we have called out from the Invocation Stub but have not
       // created the stack frame of the callee. Attempt to locate the exit
       // frame before walking the stack.
       if (!NextExit() || !ValidFramePointer()) {
         // Nothing to sample.
         sample_->set_ignore_sample(true);
         return;
       }
     }
-    for (int i = 0; i < FLAG_profile_depth; i++) {
+    for (int i = 0; i < NumberOfFramesToCollect(); i++) {
       sample_->SetAt(i, reinterpret_cast<uword>(pc_));
       if (!Next()) {
         return;
       }
     }
+    sample_->set_truncated_trace(true);
   }
 
  private:
   bool Next() {
     if (!ValidFramePointer()) {
       return false;
     }
     if (StubCode::InInvocationStubForIsolate(isolate_,
                                              reinterpret_cast<uword>(pc_))) {
       // In invocation stub.
@@ skipping 132 matching lines @@
     if (gap >= kMaxStep) {
       // Gap between frame pointer and stack pointer is
       // too large.
       return;
     }
 
     if (!ValidFramePointer(fp)) {
       return;
     }
 
-    for (int i = 0; i < FLAG_profile_depth; i++) {
+    for (int i = 0; i < NumberOfFramesToCollect(); i++) {
       sample_->SetAt(i, reinterpret_cast<uword>(pc));
 
       pc = CallerPC(fp);
       previous_fp = fp;
       fp = CallerFP(fp);
 
       if (fp == NULL) {
         return;
       }
 
       if (fp <= previous_fp) {
         // Frame pointer did not move to a higher address.
         return;
       }
 
       gap = fp - previous_fp;
       if (gap >= kMaxStep) {
         // Frame pointer step is too large.
         return;
       }
 
       if (!ValidFramePointer(fp)) {
         // Frame pointer is outside of isolate stack boundary.
         return;
       }
 
       // Move the lower bound up.
       lower_bound_ = reinterpret_cast<uword>(fp);
     }
+
+    sample_->set_truncated_trace(true);
   }
 
  private:
   uword* CallerPC(uword* fp) const {
     ASSERT(fp != NULL);
     uword* caller_pc_ptr = fp + kSavedCallerPcSlotFromFp;
     // This may actually be uninitialized, by design (see class comment above).
     MSAN_UNPOISON(caller_pc_ptr, kWordSize);
     ASAN_UNPOISON(caller_pc_ptr, kWordSize);
     return reinterpret_cast<uword*>(*caller_pc_ptr);
@@ skipping 217 matching lines @@
                                         state.fp,
                                         sp);
     stackWalker.walk();
   } else {
     sample->set_vm_tag(VMTag::kEmbedderTagId);
     sample->SetAt(0, state.pc);
   }
 }
 
 }  // namespace dart