Add Function based profile tree

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/bitfield.h"
 #include "vm/code_observers.h"
@@ skipping 88 matching lines @@
     return isolate_;
   }
 
  private:
   Isolate* isolate_;
   intptr_t visited_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(SampleVisitor);
 };
 
+
+class FixTopFrameVisitor : public SampleVisitor {
+ public:
+  explicit FixTopFrameVisitor(Isolate* isolate);
+
+  virtual void VisitSample(Sample* sample);
+
+ private:
+  void CheckForMissingDartFrame(const Code& code, Sample* sample) const;
+
+  bool ContainedInDartCodeHeaps(uword pc) const;
+
+  Isolate* vm_isolate() const {
+    return vm_isolate_;
+  }
+
+  RawCode* FindCodeForPC(uword pc) const;
+
+  Isolate* vm_isolate_;
+};
+
+
 // 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::kDefaultUserTag;
     sp_ = 0;
+    possible_return_address_ = 0;
     fp_ = 0;
     state_ = 0;
     uword* pcs = GetPCArray();
     for (intptr_t i = 0; i < pcs_length_; i++) {
       pcs[i] = 0;
     }
   }
 
   // Isolate sample was taken from.
   Isolate* isolate() const {
@@ skipping 53 matching lines @@
   }
 
   uword fp() const {
     return fp_;
   }
 
   void set_fp(uword fp) {
     fp_ = fp;
   }
 
+  uword possible_return_address() const {
+    return possible_return_address_;
+  }
+
+  void set_possible_return_address(uword possible_return_address) {
+    possible_return_address_ = possible_return_address;
+  }
+
   void InsertCallerForTopFrame(uword pc) {
     if (pcs_length_ == 1) {
       // Only sampling top frame.
       return;
     }
     uword* pcs = GetPCArray();
     // The caller for the top frame is store at index 1.
     // Shift all entries down by one.
     for (intptr_t i = pcs_length_ - 1; i >= 2; i--) {
       pcs[i] = pcs[i - 1];
     }
     // Insert caller for top frame.
     pcs[1] = pc;
+    set_missing_frame_inserted(true);
   }
 
   bool processed() const {
     return ProcessedBit::decode(state_);
   }
 
   void set_processed(bool processed) {
     state_ = ProcessedBit::update(processed, state_);
   }
 
@@ skipping 14 matching lines @@
   }
 
   bool exit_frame_sample() const {
     return ExitFrameBit::decode(state_);
   }
 
   void set_exit_frame_sample(bool exit_frame_sample) {
     state_ = ExitFrameBit::update(exit_frame_sample, state_);
   }
 
+  bool missing_frame_inserted() const {
+    return MissingFrameInsertedBit::decode(state_);
+  }
+
+  void set_missing_frame_inserted(bool missing_frame_inserted) {
+    state_ = MissingFrameInsertedBit::update(missing_frame_inserted, state_);
+  }
+
   static void InitOnce();
 
   static intptr_t instance_size() {
     return instance_size_;
   }
 
   uword* GetPCArray() const;
 
+  static const int kStackBufferSizeInWords = 3;
+  uword* GetStackBuffer() {
+    return &stack_buffer_[0];
+  }
+
  private:
   static intptr_t instance_size_;
   static intptr_t pcs_length_;
   enum StateBits {
     kProcessedBit = 0,
     kLeafFrameIsDartBit = 1,
     kIgnoreBit = 2,
     kExitFrameBit = 3,
+    kMissingFrameInsertedBit = 4,
   };
   class ProcessedBit : public BitField<bool, kProcessedBit, 1> {};
   class LeafFrameIsDart : public BitField<bool, kLeafFrameIsDartBit, 1> {};
   class IgnoreBit : public BitField<bool, kIgnoreBit, 1> {};
   class ExitFrameBit : public BitField<bool, kExitFrameBit, 1> {};
-
+  class MissingFrameInsertedBit
+    : public BitField<bool, kMissingFrameInsertedBit, 1> {};
   int64_t timestamp_;
   ThreadId tid_;
   Isolate* isolate_;
   uword pc_marker_;
+  uword stack_buffer_[kStackBufferSizeInWords];
+  uword possible_return_address_;
   uword vm_tag_;
   uword user_tag_;
   uword sp_;
   uword fp_;
   uword state_;
 
   /* There are a variable number of words that follow, the words hold the
    * sampled pc values. Access via GetPCArray() */
 
   DISALLOW_COPY_AND_ASSIGN(Sample);
@@ skipping 52 matching lines @@
   intptr_t capacity_;
   uintptr_t cursor_;
 
   DISALLOW_COPY_AND_ASSIGN(SampleBuffer);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_PROFILER_H_