Fixed missing method referenced when MallocHooks is unsupported.

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 298 matching lines @@
     return true;
   }
   const int64_t timestamp = sample->timestamp();
   int64_t delta = timestamp - time_origin_micros_;
   return (delta >= 0) && (delta <= time_extent_micros_);
 }
 
 
 bool SampleFilter::TaskFilterSample(Sample* sample) {
   const intptr_t task = static_cast<intptr_t>(sample->thread_task());
+  if (thread_task_mask_ == kNoTaskFilter) {
+    return true;
+  }
   return (task & thread_task_mask_) != 0;
 }
 
 
 ClearProfileVisitor::ClearProfileVisitor(Isolate* isolate)
     : SampleVisitor(isolate->main_port()) {}
 
 
 void ClearProfileVisitor::VisitSample(Sample* sample) {
   sample->Clear();
@@ skipping 602 matching lines @@
   sample->set_user_tag(isolate->user_tag());
   sample->set_thread_task(thread->task_kind());
   return sample;
 }
 
 
 static Sample* SetupSampleNative(SampleBuffer* sample_buffer, ThreadId tid) {
   Sample* sample = sample_buffer->ReserveSample();
   sample->Init(ILLEGAL_PORT, OS::GetCurrentMonotonicMicros(), tid);
   sample->set_is_native_allocation_sample(true);
-
   Thread* thread = Thread::Current();
 
-  // TODO(bkonyi) Any samples created while a current thread doesn't exist are
-  // ignored by the NativeAllocationSampleFilter since the default task is
-  // kUnknownTask. Is this what we want to do?
+  // Note: setting thread task in order to be consistent with other samples. The
+  // task kind is not used by NativeAllocationSampleFilter for filtering
+  // purposes as some samples may be collected when no thread exists.
   if (thread != NULL) {
     sample->set_thread_task(thread->task_kind());
   }
   return sample;
 }
 
 
 static bool CheckIsolate(Isolate* isolate) {
   if ((isolate == NULL) || (Dart::vm_isolate() == NULL)) {
     // No isolate.
@@ skipping 128 matching lines @@
   } else {
     // Fall back.
     uintptr_t pc = OS::GetProgramCounter();
     Sample* sample = SetupSample(thread, sample_buffer, os_thread->trace_id());
     sample->SetAllocationCid(cid);
     sample->SetAt(0, pc);
   }
 }
 
 
-Sample* Profiler::SampleNativeAllocation(intptr_t skip_count) {
+Sample* Profiler::SampleNativeAllocation(intptr_t skip_count,
+                                         uword address,
+                                         uintptr_t allocation_size) {
   SampleBuffer* sample_buffer = Profiler::sample_buffer();
   if (sample_buffer == NULL) {
     return NULL;
   }
 
   uintptr_t sp = Thread::GetCurrentStackPointer();
   uintptr_t fp = 0;
   uintptr_t pc = OS::GetProgramCounter();
 
   COPY_FP_REGISTER(fp);
 
   uword stack_lower = 0;
   uword stack_upper = 0;
   if (!InitialRegisterCheck(pc, fp, sp)) {
     AtomicOperations::IncrementInt64By(
         &counters_.failure_native_allocation_sample, 1);
     return NULL;
   }
 
   if (!(OSThread::GetCurrentStackBounds(&stack_lower, &stack_upper) &&
         ValidateThreadStackBounds(fp, sp, stack_lower, stack_upper))) {
     // Could not get stack boundary.
     AtomicOperations::IncrementInt64By(
         &counters_.failure_native_allocation_sample, 1);
     return NULL;
   }
 
   OSThread* os_thread = OSThread::Current();
   Sample* sample = SetupSampleNative(sample_buffer, os_thread->trace_id());
+  sample->set_native_allocation_address(address);
+  sample->set_native_allocation_size_bytes(allocation_size);
+
   ProfilerNativeStackWalker native_stack_walker(
       ILLEGAL_PORT, sample, sample_buffer, stack_lower, stack_upper, pc, fp, sp,
       skip_count);
+
   native_stack_walker.walk();
   return sample;
 }
 
 
 void Profiler::SampleThreadSingleFrame(Thread* thread, uintptr_t pc) {
   ASSERT(thread != NULL);
   OSThread* os_thread = thread->os_thread();
   ASSERT(os_thread != NULL);
   Isolate* isolate = thread->isolate();
@@ skipping 312 matching lines @@
 
 ProcessedSample* SampleBuffer::BuildProcessedSample(
     Sample* sample,
     const CodeLookupTable& clt) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
 
   ProcessedSample* processed_sample = new (zone) ProcessedSample();
 
   // Copy state bits from sample.
+  processed_sample->set_native_allocation_size_bytes(
+      sample->native_allocation_size_bytes());
   processed_sample->set_timestamp(sample->timestamp());
   processed_sample->set_tid(sample->tid());
   processed_sample->set_vm_tag(sample->vm_tag());
   processed_sample->set_user_tag(sample->user_tag());
   if (sample->is_allocation_sample()) {
     processed_sample->set_allocation_cid(sample->allocation_cid());
   }
   processed_sample->set_first_frame_executing(!sample->exit_frame_sample());
 
   // Copy stack trace from sample(s).
@@ skipping 122 matching lines @@
 
 
 ProcessedSampleBuffer::ProcessedSampleBuffer()
     : code_lookup_table_(new CodeLookupTable(Thread::Current())) {
   ASSERT(code_lookup_table_ != NULL);
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart