Fix edge case where profiler would miss the caller of the top frame

runtime/vm/profiler.h

 // 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.
 
 #ifndef VM_PROFILER_H_
 #define VM_PROFILER_H_
 
 #include "vm/allocation.h"
 #include "vm/code_observers.h"
 #include "vm/globals.h"
@@ skipping 65 matching lines @@
   }
 
  private:
   SampleBuffer* sample_buffer_;
   bool own_sample_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(IsolateProfilerData);
 };
 
 
-class SampleVisitor {
+class SampleVisitor : public ValueObject {
  public:
   explicit SampleVisitor(Isolate* isolate) : isolate_(isolate), visited_(0) { }
   virtual ~SampleVisitor() {}
 
   virtual void VisitSample(Sample* sample) = 0;
 
   intptr_t visited() const {
     return visited_;
   }
 
@@ skipping 15 matching lines @@
 // The maximum number of stack frames a sample can hold.
 #define kSampleFramesSize 256
 
 // Each Sample holds a stack trace from an isolate.
 class Sample {
  public:
   void Init(Isolate* isolate, int64_t timestamp, ThreadId tid) {
     timestamp_ = timestamp;
     tid_ = tid;
     isolate_ = isolate;
+    pc_marker_ = 0;
     vm_tag_ = VMTag::kInvalidTagId;
     user_tag_ = UserTags::kNoUserTag;
+    sp_ = 0;
+    fp_ = 0;
+    state_ = 0;
     for (intptr_t i = 0; i < kSampleFramesSize; i++) {
       pcs_[i] = 0;
     }
   }
 
   // Isolate sample was taken from.
   Isolate* isolate() const {
     return isolate_;
   }
 
@@ skipping 24 matching lines @@
     vm_tag_ = tag;
   }
 
   uword user_tag() const {
     return user_tag_;
   }
   void set_user_tag(uword tag) {
     user_tag_ = tag;
   }
 
+  uword pc_marker() const {
+    return pc_marker_;
+  }
+
+  void set_pc_marker(uword pc_marker) {
+    pc_marker_ = pc_marker;
+  }
+
+  uword sp() {

[siva, 2014/05/02 20:43:37]

const

+    return sp_;
+  }
+
+  void set_sp(uword sp) {
+    sp_ = sp;
+  }
+
+  uword fp() {

[siva, 2014/05/02 20:43:37]

const

+    return fp_;
+  }
+
+  void set_fp(uword fp) {
+    fp_ = fp;
+  }
+
+  void InsertCallerForTopFrame(uword pc) {
+    // Shift all entries down.

[siva, 2014/05/02 20:43:37]

Maybe you should add a comment here indicating what is going on and why the slot
is always 1.

+    for (intptr_t i = 1; i < kSampleFramesSize - 1; i++) {
+      pcs_[i + 1] = pcs_[i];
+    }
+    pcs_[1] = pc;
+  }
+
+  bool processed() const {
+    return ProcessedBit::decode(state_);
+  }
+
+  void set_processed(bool processed) {
+    state_ = ProcessedBit::update(processed, state_);
+  }
+
+  bool leaf_frame_is_dart() const {
+    return LeafFrameIsDart::decode(state_);
+  }
+
+  void set_leaf_frame_is_dart(bool leaf_frame_is_dart) {
+    state_ = LeafFrameIsDart::update(leaf_frame_is_dart, state_);
+  }
+
  private:
+  class ProcessedBit : public BitField<bool, 0, 1> {};
+  class LeafFrameIsDart : public BitField<bool, 1, 1> {};

[siva, 2014/05/02 20:43:37]

it would be more readable to enumerate the bits, e.g:
  enum StateBits {
    kConstBit = 0,
    kImplementedBit = 1,
    kTypeFinalizedBit = 2,
    kClassFinalizedPos = 3,
    kClassFinalizedSize = 2,
    kAbstractBit = kClassFinalizedPos + kClassFinalizedSize,  // = 5
    kPatchBit = 6,
    kSynthesizedClassBit = 7,
    kMarkedForParsingBit = 8,
    kMixinAppAliasBit = 9,
    kMixinTypeAppliedBit = 10,
    kFieldsMarkedNullableBit = 11,
    kCycleFreeBit = 12,
  };
  class ConstBit : public BitField<bool, kConstBit, 1> {};
  class ImplementedBit : public BitField<bool, kImplementedBit, 1> {};

   int64_t timestamp_;
   ThreadId tid_;
   Isolate* isolate_;
+  uword pc_marker_;
   uword vm_tag_;
   uword user_tag_;
+  uword sp_;
+  uword fp_;
+  uword state_;
   uword pcs_[kSampleFramesSize];
 };
 
 
 // Ring buffer of Samples that is (usually) shared by many isolates.
 class SampleBuffer {
  public:
   static const intptr_t kDefaultBufferCapacity = 120000;  // 2 minutes @ 1000hz.
 
   explicit SampleBuffer(intptr_t capacity = kDefaultBufferCapacity) {
@@ skipping 16 matching lines @@
   Sample* ReserveSample();
 
   Sample* At(intptr_t idx) const {
     ASSERT(idx >= 0);
     ASSERT(idx < capacity_);
     return &samples_[idx];
   }
 
   void VisitSamples(SampleVisitor* visitor) {
     ASSERT(visitor != NULL);
-    Sample sample;
     const intptr_t length = capacity();
     for (intptr_t i = 0; i < length; i++) {
-      // Copy the sample.
-      sample = *At(i);
-      if (sample.isolate() != visitor->isolate()) {
+      Sample* sample = At(i);
+      if (sample->isolate() != visitor->isolate()) {
         // Another isolate.
         continue;
       }
-      if (sample.timestamp() == 0) {
+      if (sample->timestamp() == 0) {
         // Empty.
         continue;
       }
-      if (sample.At(0) == 0) {
+      if (sample->At(0) == 0) {
         // No frames.
         continue;
       }
       visitor->IncrementVisited();
-      visitor->VisitSample(&sample);
+      visitor->VisitSample(sample);
     }
   }
 
  private:
   Sample* samples_;
   intptr_t capacity_;
   uintptr_t cursor_;
 
   DISALLOW_COPY_AND_ASSIGN(SampleBuffer);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_PROFILER_H_