Fixed missing method referenced when MallocHooks is unsupported.

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 RUNTIME_VM_PROFILER_H_
 #define RUNTIME_VM_PROFILER_H_
 
 #include "vm/allocation.h"
 #include "vm/bitfield.h"
 #include "vm/code_observers.h"
 #include "vm/globals.h"
 #include "vm/growable_array.h"
+#include "vm/malloc_hooks.h"
 #include "vm/object.h"
 #include "vm/tags.h"
 #include "vm/thread_interrupter.h"
 
 // Profiler sampling and stack walking support.
 // NOTE: For service related code, see profile_service.h.
 
 namespace dart {
 
 // Forward declarations.
@@ skipping 30 matching lines @@
 
   static void SetSampleDepth(intptr_t depth);
   static void SetSamplePeriod(intptr_t period);
 
   static SampleBuffer* sample_buffer() { return sample_buffer_; }
 
   static void DumpStackTrace(void* context);
   static void DumpStackTrace();
 
   static void SampleAllocation(Thread* thread, intptr_t cid);
-  static Sample* SampleNativeAllocation(intptr_t skip_count);
+  static Sample* SampleNativeAllocation(intptr_t skip_count,
+                                        uword address,
+                                        uintptr_t allocation_size);
 
   // SampleThread is called from inside the signal handler and hence it is very
   // critical that the implementation of SampleThread does not do any of the
   // following:
   //   * Accessing TLS -- Because on Windows the callback will be running in a
   //                      different thread.
   //   * Allocating memory -- Because this takes locks which may already be
   //                          held, resulting in a dead lock.
   //   * Taking a lock -- See above.
   static void SampleThread(Thread* thread, const InterruptedThreadState& state);
@@ skipping 60 matching lines @@
   virtual bool FilterSample(Sample* sample) { return true; }
 
   Dart_Port port() const { return port_; }
 
   // Returns |true| if |sample| passes the time filter.
   bool TimeFilterSample(Sample* sample);
 
   // Returns |true| if |sample| passes the thread task filter.
   bool TaskFilterSample(Sample* sample);
 
+  static const intptr_t kNoTaskFilter = -1;
+
  private:
   Dart_Port port_;
   intptr_t thread_task_mask_;
   int64_t time_origin_micros_;
   int64_t time_extent_micros_;
 };
 
 
 class ClearProfileVisitor : public SampleVisitor {
  public:
@@ skipping 22 matching lines @@
     port_ = ILLEGAL_PORT;
     pc_marker_ = 0;
     for (intptr_t i = 0; i < kStackBufferSizeInWords; i++) {
       stack_buffer_[i] = 0;
     }
     vm_tag_ = VMTag::kInvalidTagId;
     user_tag_ = UserTags::kDefaultUserTag;
     lr_ = 0;
     metadata_ = 0;
     state_ = 0;
+    native_allocation_address_ = 0;
+    native_allocation_size_bytes_ = 0;
     continuation_index_ = -1;
     uword* pcs = GetPCArray();
     for (intptr_t i = 0; i < pcs_length_; i++) {
       pcs[i] = 0;
     }
     set_head_sample(true);
   }
 
   // Timestamp sample was taken at.
   int64_t timestamp() const { return timestamp_; }
@@ skipping 76 matching lines @@
 
   bool is_native_allocation_sample() const {
     return NativeAllocationSampleBit::decode(state_);
   }
 
   void set_is_native_allocation_sample(bool native_allocation_sample) {
     state_ =
         NativeAllocationSampleBit::update(native_allocation_sample, state_);
   }
 
+  void set_native_allocation_address(uword address) {
+    native_allocation_address_ = address;
+  }
+
+  uword native_allocation_address() const { return native_allocation_address_; }
+
+  uintptr_t native_allocation_size_bytes() const {
+    return native_allocation_size_bytes_;
+  }
+
+  void set_native_allocation_size_bytes(uintptr_t size) {
+    native_allocation_size_bytes_ = size;
+  }
+
   Thread::TaskKind thread_task() const { return ThreadTaskBit::decode(state_); }
 
   void set_thread_task(Thread::TaskKind task) {
     state_ = ThreadTaskBit::update(task, state_);
   }
 
   bool is_continuation_sample() const {
     return ContinuationSampleBit::decode(state_);
   }
 
@@ skipping 74 matching lines @@
   int64_t timestamp_;
   ThreadId tid_;
   Dart_Port port_;
   uword pc_marker_;
   uword stack_buffer_[kStackBufferSizeInWords];
   uword vm_tag_;
   uword user_tag_;
   uword metadata_;
   uword lr_;
   uword state_;
+  uword native_allocation_address_;
+  uintptr_t native_allocation_size_bytes_;
   intptr_t continuation_index_;
 
   /* There are a variable number of words that follow, the words hold the
    * sampled pc values. Access via GetPCArray() */
 
   DISALLOW_COPY_AND_ASSIGN(Sample);
 };
 
 
+class NativeAllocationSampleFilter : public SampleFilter {
+ public:
+  NativeAllocationSampleFilter(int64_t time_origin_micros,
+                               int64_t time_extent_micros)
+      : SampleFilter(ILLEGAL_PORT,
+                     SampleFilter::kNoTaskFilter,
+                     time_origin_micros,
+                     time_extent_micros) {}
+
+  bool FilterSample(Sample* sample) {
+    if (!sample->is_native_allocation_sample()) {
+      return false;
+    }
+    // If the sample is an allocation sample, we need to check that the
+    // memory at the address hasn't been freed, and if the address associated
+    // with the allocation has been freed and then reissued.
+    void* alloc_address =
+        reinterpret_cast<void*>(sample->native_allocation_address());
+    Sample* recorded_sample = MallocHooks::GetSample(alloc_address);
+    return (sample == recorded_sample);
+  }
+};
+
+
 // A Code object descriptor.
 class CodeDescriptor : public ZoneAllocated {
  public:
   explicit CodeDescriptor(const Code& code);
 
   uword Start() const;
 
   uword Size() const;
 
   int64_t CompileTimestamp() const;
@@ skipping 162 matching lines @@
   // The user tag.
   uword user_tag() const { return user_tag_; }
   void set_user_tag(uword tag) { user_tag_ = tag; }
 
   // The class id if this is an allocation profile sample. -1 otherwise.
   intptr_t allocation_cid() const { return allocation_cid_; }
   void set_allocation_cid(intptr_t cid) { allocation_cid_ = cid; }
 
   bool IsAllocationSample() const { return allocation_cid_ > 0; }
 
+  bool is_native_allocation_sample() const {
+    return native_allocation_size_bytes_ != 0;
+  }
+
+  uintptr_t native_allocation_size_bytes() const {
+    return native_allocation_size_bytes_;
+  }
+  void set_native_allocation_size_bytes(uintptr_t allocation_size) {
+    native_allocation_size_bytes_ = allocation_size;
+  }
+
   // Was the stack trace truncated?
   bool truncated() const { return truncated_; }
   void set_truncated(bool truncated) { truncated_ = truncated; }
 
   // Was the first frame in the stack trace executing?
   bool first_frame_executing() const { return first_frame_executing_; }
   void set_first_frame_executing(bool first_frame_executing) {
     first_frame_executing_ = first_frame_executing;
   }
 
@@ skipping 14 matching lines @@
                                 uword* stack_buffer);
 
   ZoneGrowableArray<uword> pcs_;
   int64_t timestamp_;
   ThreadId tid_;
   uword vm_tag_;
   uword user_tag_;
   intptr_t allocation_cid_;
   bool truncated_;
   bool first_frame_executing_;
+  uword native_allocation_address_;
+  uintptr_t native_allocation_size_bytes_;
   ProfileTrieNode* timeline_trie_;
 
   friend class SampleBuffer;
   DISALLOW_COPY_AND_ASSIGN(ProcessedSample);
 };
 
 
 // A collection of |ProcessedSample|s.
 class ProcessedSampleBuffer : public ZoneAllocated {
  public:
@@ skipping 12 matching lines @@
  private:
   ZoneGrowableArray<ProcessedSample*> samples_;
   CodeLookupTable* code_lookup_table_;
 
   DISALLOW_COPY_AND_ASSIGN(ProcessedSampleBuffer);
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_PROFILER_H_