VM: Re-format to use at most one newline between functions

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 61 matching lines @@
   sample_buffer_ = new SampleBuffer();
   Profiler::InitAllocationSampleBuffer();
   // Zero counters.
   memset(&counters_, 0, sizeof(counters_));
   NativeSymbolResolver::InitOnce();
   ThreadInterrupter::SetInterruptPeriod(FLAG_profile_period);
   ThreadInterrupter::Startup();
   initialized_ = true;
 }
 
-
 void Profiler::InitAllocationSampleBuffer() {
   if (FLAG_profiler_native_memory &&
       (Profiler::allocation_sample_buffer_ == NULL)) {
     Profiler::allocation_sample_buffer_ = new AllocationSampleBuffer();
   }
 }
 
-
 void Profiler::Shutdown() {
   if (!FLAG_profiler) {
     return;
   }
   ASSERT(initialized_);
   ThreadInterrupter::Shutdown();
   NativeSymbolResolver::ShutdownOnce();
 }
 
-
 void Profiler::SetSampleDepth(intptr_t depth) {
   const int kMinimumDepth = 2;
   const int kMaximumDepth = 255;
   if (depth < kMinimumDepth) {
     FLAG_max_profile_depth = kMinimumDepth;
   } else if (depth > kMaximumDepth) {
     FLAG_max_profile_depth = kMaximumDepth;
   } else {
     FLAG_max_profile_depth = depth;
   }
 }
 
-
 void Profiler::SetSamplePeriod(intptr_t period) {
   const int kMinimumProfilePeriod = 50;
   if (period < kMinimumProfilePeriod) {
     FLAG_profile_period = kMinimumProfilePeriod;
   } else {
     FLAG_profile_period = period;
   }
 }
 
-
 intptr_t Sample::pcs_length_ = 0;
 intptr_t Sample::instance_size_ = 0;
 
-
 void Sample::InitOnce() {
   pcs_length_ = kSampleSize;
   instance_size_ = sizeof(Sample) + (sizeof(uword) * pcs_length_);  // NOLINT.
 }
 
-
 uword* Sample::GetPCArray() const {
   return reinterpret_cast<uword*>(reinterpret_cast<uintptr_t>(this) +
                                   sizeof(*this));
 }
 
-
 SampleBuffer::SampleBuffer(intptr_t capacity) {
   ASSERT(Sample::instance_size() > 0);
 
   const intptr_t size = Utils::RoundUp(capacity * Sample::instance_size(),
                                        VirtualMemory::PageSize());
   const bool kNotExecutable = false;
   memory_ = VirtualMemory::Reserve(size);
   if ((memory_ == NULL) || !memory_->Commit(kNotExecutable, "dart-profiler")) {
     OUT_OF_MEMORY();
   }
 
   samples_ = reinterpret_cast<Sample*>(memory_->address());
   capacity_ = capacity;
   cursor_ = 0;
 
   if (FLAG_trace_profiler) {
     OS::Print("Profiler holds %" Pd " samples\n", capacity);
     OS::Print("Profiler sample is %" Pd " bytes\n", Sample::instance_size());
     OS::Print("Profiler memory usage = %" Pd " bytes\n", size);
   }
 }
 
-
 AllocationSampleBuffer::AllocationSampleBuffer(intptr_t capacity)
     : SampleBuffer(capacity), mutex_(new Mutex()) {}
 
-
 SampleBuffer::~SampleBuffer() {
   delete memory_;
 }
 
-
 AllocationSampleBuffer::~AllocationSampleBuffer() {
   delete mutex_;
 }
 
-
 Sample* SampleBuffer::At(intptr_t idx) const {
   ASSERT(idx >= 0);
   ASSERT(idx < capacity_);
   intptr_t offset = idx * Sample::instance_size();
   uint8_t* samples = reinterpret_cast<uint8_t*>(samples_);
   return reinterpret_cast<Sample*>(samples + offset);
 }
 
-
 intptr_t SampleBuffer::ReserveSampleSlot() {
   ASSERT(samples_ != NULL);
   uintptr_t cursor = AtomicOperations::FetchAndIncrement(&cursor_);
   // Map back into sample buffer range.
   cursor = cursor % capacity_;
   return cursor;
 }
 
-
 Sample* SampleBuffer::ReserveSample() {
   return At(ReserveSampleSlot());
 }
 
-
 Sample* SampleBuffer::ReserveSampleAndLink(Sample* previous) {
   ASSERT(previous != NULL);
   intptr_t next_index = ReserveSampleSlot();
   Sample* next = At(next_index);
   next->Init(previous->port(), previous->timestamp(), previous->tid());
   next->set_head_sample(false);
   // Mark that previous continues at next.
   previous->SetContinuationIndex(next_index);
   return next;
 }
 
-
 void AllocationSampleBuffer::FreeAllocationSample(Sample* sample) {
   MutexLocker ml(mutex_);
   while (sample != NULL) {
     intptr_t continuation_index = -1;
     if (sample->is_continuation_sample()) {
       continuation_index = sample->continuation_index();
     }
     sample->Clear();
     sample->set_next_free(free_sample_list_);
     free_sample_list_ = sample;
 
     if (continuation_index != -1) {
       sample = At(continuation_index);
     } else {
       sample = NULL;
     }
   }
 }
 
-
 intptr_t AllocationSampleBuffer::ReserveSampleSlotLocked() {
   if (free_sample_list_ != NULL) {
     Sample* free_sample = free_sample_list_;
     free_sample_list_ = free_sample->next_free();
     free_sample->set_next_free(NULL);
     uint8_t* samples_array_ptr = reinterpret_cast<uint8_t*>(samples_);
     uint8_t* free_sample_ptr = reinterpret_cast<uint8_t*>(free_sample);
     return static_cast<intptr_t>((free_sample_ptr - samples_array_ptr) /
                                  Sample::instance_size());
   } else if (cursor_ < static_cast<uintptr_t>(capacity_ - 1)) {
     return cursor_++;
   } else {
     return -1;
   }
 }
 
-
 Sample* AllocationSampleBuffer::ReserveSampleAndLink(Sample* previous) {
   MutexLocker ml(mutex_);
   ASSERT(previous != NULL);
   intptr_t next_index = ReserveSampleSlotLocked();
   if (next_index < 0) {
     // Could not find a free sample.
     return NULL;
   }
   Sample* next = At(next_index);
   next->Init(previous->port(), previous->timestamp(), previous->tid());
   next->set_native_allocation_address(previous->native_allocation_address());
   next->set_native_allocation_size_bytes(
       previous->native_allocation_size_bytes());
   next->set_head_sample(false);
   // Mark that previous continues at next.
   previous->SetContinuationIndex(next_index);
   return next;
 }
 
-
 Sample* AllocationSampleBuffer::ReserveSample() {
   MutexLocker ml(mutex_);
   intptr_t index = ReserveSampleSlotLocked();
   if (index < 0) {
     return NULL;
   }
   return At(index);
 }
 
-
 // Attempts to find the true return address when a Dart frame is being setup
 // or torn down.
 // NOTE: Architecture specific implementations below.
 class ReturnAddressLocator : public ValueObject {
  public:
   ReturnAddressLocator(Sample* sample, const Code& code)
       : stack_buffer_(sample->GetStackBuffer()),
         pc_(sample->pc()),
         code_(Code::ZoneHandle(code.raw())) {
     ASSERT(!code_.IsNull());
@@ skipping 32 matching lines @@
     ASSERT(i < Sample::kStackBufferSizeInWords);
     return stack_buffer_[i];
   }
 
  private:
   uword* stack_buffer_;
   uword pc_;
   const Code& code_;
 };
 
-
 #if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64)
 bool ReturnAddressLocator::LocateReturnAddress(uword* return_address) {
   ASSERT(return_address != NULL);
   const intptr_t offset = RelativePC();
   ASSERT(offset >= 0);
   const intptr_t size = code_.Size();
   ASSERT(offset < size);
   const intptr_t prologue_offset = code_.GetPrologueOffset();
   if (offset < prologue_offset) {
     // Before the prologue, return address is at the top of the stack.
@@ skipping 48 matching lines @@
 }
 #elif defined(TARGET_ARCH_DBC)
 bool ReturnAddressLocator::LocateReturnAddress(uword* return_address) {
   ASSERT(return_address != NULL);
   return false;
 }
 #else
 #error ReturnAddressLocator implementation missing for this architecture.
 #endif
 
-
 bool SampleFilter::TimeFilterSample(Sample* sample) {
   if ((time_origin_micros_ == -1) || (time_extent_micros_ == -1)) {
     // No time filter passed in, always pass.
     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();
 }
 
-
 static void DumpStackFrame(intptr_t frame_index, uword pc) {
   Isolate* isolate = Isolate::Current();
   if ((isolate != NULL) && isolate->is_runnable()) {
     Code& code = Code::Handle(Code::LookupCodeInVmIsolate(pc));
     if (!code.IsNull()) {
       OS::PrintErr("  [0x%" Pp "] %s\n", pc, code.QualifiedName());
       return;
     }
     code = Code::LookupCode(pc);
     if (!code.IsNull()) {
       OS::PrintErr("  [0x%" Pp "] %s\n", pc, code.QualifiedName());
       return;
     }
   }
 
   uintptr_t start = 0;
   char* native_symbol_name = NativeSymbolResolver::LookupSymbolName(pc, &start);
   if (native_symbol_name == NULL) {
     OS::PrintErr("  [0x%" Pp "] Unknown symbol\n", pc);
   } else {
     OS::PrintErr("  [0x%" Pp "] %s\n", pc, native_symbol_name);
     NativeSymbolResolver::FreeSymbolName(native_symbol_name);
   }
 }
 
-
 class ProfilerStackWalker : public ValueObject {
  public:
   ProfilerStackWalker(Dart_Port port_id,
                       Sample* head_sample,
                       SampleBuffer* sample_buffer,
                       intptr_t skip_count = 0)
       : port_id_(port_id),
         sample_(head_sample),
         sample_buffer_(sample_buffer),
         skip_count_(skip_count),
@@ skipping 45 matching lines @@
  protected:
   Dart_Port port_id_;
   Sample* sample_;
   SampleBuffer* sample_buffer_;
   intptr_t skip_count_;
   intptr_t frames_skipped_;
   intptr_t frame_index_;
   intptr_t total_frames_;
 };
 
-
 // Executing Dart code, walk the stack.
 class ProfilerDartStackWalker : public ProfilerStackWalker {
  public:
   ProfilerDartStackWalker(Thread* thread,
                           Sample* sample,
                           SampleBuffer* sample_buffer,
                           uword stack_lower,
                           uword stack_upper,
                           uword pc,
                           uword fp,
@@ skipping 173 matching lines @@
   }
 
   uword* pc_;
   uword* fp_;
   uword* sp_;
   const uword stack_upper_;
   const uword stack_lower_;
   bool has_exit_frame_;
 };
 
-
 // If the VM is compiled without frame pointers (which is the default on
 // recent GCC versions with optimizing enabled) the stack walking code may
 // fail.
 //
 class ProfilerNativeStackWalker : public ProfilerStackWalker {
  public:
   ProfilerNativeStackWalker(Dart_Port port_id,
                             Sample* sample,
                             SampleBuffer* sample_buffer,
                             uword stack_lower,
@@ skipping 92 matching lines @@
     return r;
   }
 
   const uword stack_upper_;
   const uword original_pc_;
   const uword original_fp_;
   const uword original_sp_;
   uword lower_bound_;
 };
 
-
 static void CopyStackBuffer(Sample* sample, uword sp_addr) {
   ASSERT(sample != NULL);
   uword* sp = reinterpret_cast<uword*>(sp_addr);
   uword* buffer = sample->GetStackBuffer();
   if (sp != NULL) {
     for (intptr_t i = 0; i < Sample::kStackBufferSizeInWords; i++) {
       MSAN_UNPOISON(sp, kWordSize);
       ASAN_UNPOISON(sp, kWordSize);
       buffer[i] = *sp;
       sp++;
     }
   }
 }
 
-
 #if defined(HOST_OS_WINDOWS)
 // On Windows this code is synchronously executed from the thread interrupter
 // thread. This means we can safely have a static fault_address.
 static uword fault_address = 0;
 static LONG GuardPageExceptionFilter(EXCEPTION_POINTERS* ep) {
   fault_address = 0;
   if (ep->ExceptionRecord->ExceptionCode != STATUS_GUARD_PAGE_VIOLATION) {
     return EXCEPTION_CONTINUE_SEARCH;
   }
   // https://goo.gl/p5Fe10
@@ skipping 58 matching lines @@
     BOOL success =
         VirtualProtect(reinterpret_cast<void*>(fault_address),
                        sizeof(fault_address), new_protect, &old_protect);
     USE(success);
     ASSERT(success);
     ASSERT(old_protect == PAGE_READWRITE);
   }
 #endif
 }
 
-
 static bool ValidateThreadStackBounds(uintptr_t fp,
                                       uintptr_t sp,
                                       uword stack_lower,
                                       uword stack_upper) {
   if (stack_lower >= stack_upper) {
     // Stack boundary is invalid.
     return false;
   }
 
   if ((sp < stack_lower) || (sp >= stack_upper)) {
     // Stack pointer is outside thread's stack boundary.
     return false;
   }
 
   if ((fp < stack_lower) || (fp >= stack_upper)) {
     // Frame pointer is outside threads's stack boundary.
     return false;
   }
 
   return true;
 }
 
-
 // Get |isolate|'s stack boundary and verify that |sp| and |fp| are within
 // it. If |get_os_thread_bounds| is true then if |isolate| stackbounds are
 // not available we fallback to using underlying OS thread bounds. This only
 // works for the current thread.
 // Return |false| if anything looks suspicious.
 static bool GetAndValidateThreadStackBounds(Thread* thread,
                                             uintptr_t fp,
                                             uintptr_t sp,
                                             uword* stack_lower,
                                             uword* stack_upper,
@@ skipping 35 matching lines @@
   }
 
   if (!use_simulator_stack_bounds && (sp > *stack_lower)) {
     // The stack pointer gives us a tighter lower bound.
     *stack_lower = sp;
   }
 
   return ValidateThreadStackBounds(fp, sp, *stack_lower, *stack_upper);
 }
 
-
 // Some simple sanity checking of |pc|, |fp|, and |sp|.
 static bool InitialRegisterCheck(uintptr_t pc, uintptr_t fp, uintptr_t sp) {
   if ((sp == 0) || (fp == 0) || (pc == 0)) {
     // None of these registers should be zero.
     return false;
   }
 
   if (sp > fp) {
     // Assuming the stack grows down, we should never have a stack pointer above
     // the frame pointer.
     return false;
   }
 
   return true;
 }
 
-
 static Sample* SetupSample(Thread* thread,
                            SampleBuffer* sample_buffer,
                            ThreadId tid) {
   ASSERT(thread != NULL);
   Isolate* isolate = thread->isolate();
   ASSERT(sample_buffer != NULL);
   Sample* sample = sample_buffer->ReserveSample();
   sample->Init(isolate->main_port(), OS::GetCurrentMonotonicMicros(), tid);
   uword vm_tag = thread->vm_tag();
 #if defined(USING_SIMULATOR) && !defined(TARGET_ARCH_DBC)
   // When running in the simulator, the runtime entry function address
   // (stored as the vm tag) is the address of a redirect function.
   // Attempt to find the real runtime entry function address and use that.
   uword redirect_vm_tag = Simulator::FunctionForRedirect(vm_tag);
   if (redirect_vm_tag != 0) {
     vm_tag = redirect_vm_tag;
   }
 #endif
   sample->set_vm_tag(vm_tag);
   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();
   if (sample == NULL) {
     return NULL;
   }
   sample->Init(ILLEGAL_PORT, OS::GetCurrentMonotonicMicros(), tid);
   Thread* thread = Thread::Current();
 
   // 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.
     return false;
   }
   return isolate != Dart::vm_isolate();
 }
 
-
 void Profiler::DumpStackTrace(void* context) {
 #if defined(HOST_OS_LINUX) || defined(HOST_OS_MACOS)
   ucontext_t* ucontext = reinterpret_cast<ucontext_t*>(context);
   mcontext_t mcontext = ucontext->uc_mcontext;
   uword pc = SignalHandler::GetProgramCounter(mcontext);
   uword fp = SignalHandler::GetFramePointer(mcontext);
   uword sp = SignalHandler::GetCStackPointer(mcontext);
   DumpStackTrace(sp, fp, pc, true /* for_crash */);
 #else
 // TODO(fschneider): Add support for more platforms.
 // Do nothing on unsupported platforms.
 #endif
 }
 
-
 void Profiler::DumpStackTrace(bool for_crash) {
   uintptr_t sp = Thread::GetCurrentStackPointer();
   uintptr_t fp = 0;
   uintptr_t pc = OS::GetProgramCounter();
 
   COPY_FP_REGISTER(fp);
 
   DumpStackTrace(sp, fp, pc, for_crash);
 }
 
-
 void Profiler::DumpStackTrace(uword sp, uword fp, uword pc, bool for_crash) {
   if (for_crash) {
     // Allow only one stack trace to prevent recursively printing stack traces
     // if we hit an assert while printing the stack.
     static uintptr_t started_dump = 0;
     if (AtomicOperations::FetchAndIncrement(&started_dump) != 0) {
       OS::PrintErr("Aborting re-entrant request for stack trace.\n");
       return;
     }
   }
@@ skipping 28 matching lines @@
     return;
   }
 
   ProfilerNativeStackWalker native_stack_walker(
       (isolate != NULL) ? isolate->main_port() : ILLEGAL_PORT, NULL, NULL,
       stack_lower, stack_upper, pc, fp, sp);
   native_stack_walker.walk();
   OS::PrintErr("-- End of DumpStackTrace\n");
 }
 
-
 void Profiler::SampleAllocation(Thread* thread, intptr_t cid) {
   ASSERT(thread != NULL);
   OSThread* os_thread = thread->os_thread();
   ASSERT(os_thread != NULL);
   Isolate* isolate = thread->isolate();
   if (!CheckIsolate(isolate)) {
     return;
   }
 
   const bool exited_dart_code = thread->HasExitedDartCode();
@@ skipping 38 matching lines @@
     dart_exit_stack_walker.walk();
   } 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,
                                          uword address,
                                          uintptr_t allocation_size) {
   AllocationSampleBuffer* sample_buffer = Profiler::allocation_sample_buffer();
   if (sample_buffer == NULL) {
     return NULL;
   }
 
   uintptr_t sp = Thread::GetCurrentStackPointer();
   uintptr_t fp = 0;
@@ skipping 34 matching lines @@
 
   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();
 
   SampleBuffer* sample_buffer = Profiler::sample_buffer();
   if (sample_buffer == NULL) {
     // Profiler not initialized.
     return;
   }
 
   // Setup sample.
   Sample* sample = SetupSample(thread, sample_buffer, os_thread->trace_id());
   // Increment counter for vm tag.
   VMTagCounters* counters = isolate->vm_tag_counters();
   ASSERT(counters != NULL);
   if (thread->IsMutatorThread()) {
     counters->Increment(sample->vm_tag());
   }
 
   // Write the single pc value.
   sample->SetAt(0, pc);
 }
 
-
 void Profiler::SampleThread(Thread* thread,
                             const InterruptedThreadState& state) {
   ASSERT(thread != NULL);
   OSThread* os_thread = thread->os_thread();
   ASSERT(os_thread != NULL);
   Isolate* isolate = thread->isolate();
 
   // Thread is not doing VM work.
   if (thread->task_kind() == Thread::kUnknownTask) {
     AtomicOperations::IncrementInt64By(&counters_.bail_out_unknown_task, 1);
@@ skipping 92 matching lines @@
   ProfilerDartStackWalker dart_stack_walker(thread, sample, sample_buffer,
                                             stack_lower, stack_upper, pc, fp,
                                             sp, exited_dart_code, false);
 
   // All memory access is done inside CollectSample.
   CollectSample(isolate, exited_dart_code, in_dart_code, sample,
                 &native_stack_walker, &dart_stack_walker, pc, fp, sp,
                 &counters_);
 }
 
-
 CodeDescriptor::CodeDescriptor(const Code& code) : code_(code) {
   ASSERT(!code_.IsNull());
 }
 
-
 uword CodeDescriptor::Start() const {
   return code_.PayloadStart();
 }
 
-
 uword CodeDescriptor::Size() const {
   return code_.Size();
 }
 
-
 int64_t CodeDescriptor::CompileTimestamp() const {
   return code_.compile_timestamp();
 }
 
-
 CodeLookupTable::CodeLookupTable(Thread* thread) {
   Build(thread);
 }
 
-
 class CodeLookupTableBuilder : public ObjectVisitor {
  public:
   explicit CodeLookupTableBuilder(CodeLookupTable* table) : table_(table) {
     ASSERT(table_ != NULL);
   }
 
   ~CodeLookupTableBuilder() {}
 
   void VisitObject(RawObject* raw_obj) {
     uint32_t tags = raw_obj->ptr()->tags_;
     if (RawObject::ClassIdTag::decode(tags) == kCodeCid) {
       RawCode* raw_code = reinterpret_cast<RawCode*>(raw_obj);
       const Code& code = Code::Handle(raw_code);
       ASSERT(!code.IsNull());
       const Instructions& instructions =
           Instructions::Handle(code.instructions());
       ASSERT(!instructions.IsNull());
       table_->Add(code);
     }
   }
 
  private:
   CodeLookupTable* table_;
 };
 
-
 void CodeLookupTable::Build(Thread* thread) {
   ASSERT(thread != NULL);
   Isolate* isolate = thread->isolate();
   ASSERT(isolate != NULL);
   Isolate* vm_isolate = Dart::vm_isolate();
   ASSERT(vm_isolate != NULL);
 
   // Clear.
   code_objects_.Clear();
 
@@ skipping 18 matching lines @@
     const CodeDescriptor* b = At(i + 1);
     ASSERT(a->Start() < b->Start());
     ASSERT(FindCode(a->Start()) == a);
     ASSERT(FindCode(b->Start()) == b);
     ASSERT(FindCode(a->Start() + a->Size() - 1) == a);
     ASSERT(FindCode(b->Start() + b->Size() - 1) == b);
   }
 #endif
 }
 
-
 void CodeLookupTable::Add(const Code& code) {
   ASSERT(!code.IsNull());
   CodeDescriptor* cd = new CodeDescriptor(code);
   code_objects_.Add(cd);
 }
 
-
 const CodeDescriptor* CodeLookupTable::FindCode(uword pc) const {
   intptr_t first = 0;
   intptr_t count = length();
   while (count > 0) {
     intptr_t current = first;
     intptr_t step = count / 2;
     current += step;
     const CodeDescriptor* cd = At(current);
     if (pc >= cd->Start()) {
       first = ++current;
@@ skipping 10 matching lines @@
   first--;
   ASSERT(first >= 0);
   ASSERT(first < length());
   const CodeDescriptor* cd = At(first);
   if (cd->Contains(pc)) {
     return cd;
   }
   return NULL;
 }
 
-
 ProcessedSampleBuffer* SampleBuffer::BuildProcessedSampleBuffer(
     SampleFilter* filter) {
   ASSERT(filter != NULL);
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
 
   ProcessedSampleBuffer* buffer = new (zone) ProcessedSampleBuffer();
 
   const intptr_t length = capacity();
   for (intptr_t i = 0; i < length; i++) {
@@ skipping 30 matching lines @@
     }
     if (!filter->FilterSample(sample)) {
       // Did not pass filter.
       continue;
     }
     buffer->Add(BuildProcessedSample(sample, buffer->code_lookup_table()));
   }
   return buffer;
 }
 
-
 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(
@@ skipping 24 matching lines @@
 
   if (!sample->exit_frame_sample()) {
     processed_sample->FixupCaller(clt, sample->pc_marker(),
                                   sample->GetStackBuffer());
   }
 
   processed_sample->set_truncated(truncated);
   return processed_sample;
 }
 
-
 Sample* SampleBuffer::Next(Sample* sample) {
   if (!sample->is_continuation_sample()) return NULL;
   Sample* next_sample = At(sample->continuation_index());
   // Sanity check.
   ASSERT(sample != next_sample);
   // Detect invalid chaining.
   if (sample->port() != next_sample->port()) {
     return NULL;
   }
   if (sample->timestamp() != next_sample->timestamp()) {
     return NULL;
   }
   if (sample->tid() != next_sample->tid()) {
     return NULL;
   }
   return next_sample;
 }
 
-
 ProcessedSample::ProcessedSample()
     : pcs_(kSampleSize),
       timestamp_(0),
       vm_tag_(0),
       user_tag_(0),
       allocation_cid_(-1),
       truncated_(false),
       timeline_trie_(NULL) {}
 
-
 void ProcessedSample::FixupCaller(const CodeLookupTable& clt,
                                   uword pc_marker,
                                   uword* stack_buffer) {
   const CodeDescriptor* cd = clt.FindCode(At(0));
   if (cd == NULL) {
     // No Dart code.
     return;
   }
   if (cd->CompileTimestamp() > timestamp()) {
     // Code compiled after sample. Ignore.
     return;
   }
   CheckForMissingDartFrame(clt, cd, pc_marker, stack_buffer);
 }
 
-
 void ProcessedSample::CheckForMissingDartFrame(const CodeLookupTable& clt,
                                                const CodeDescriptor* cd,
                                                uword pc_marker,
                                                uword* stack_buffer) {
   ASSERT(cd != NULL);
   const Code& code = Code::Handle(cd->code());
   ASSERT(!code.IsNull());
   // Some stubs (and intrinsics) do not push a frame onto the stack leaving
   // the frame pointer in the caller.
   //
@@ skipping 34 matching lines @@
   if (clt.FindCode(return_address) == NULL) {
     // Return address is not from a Dart code object. Do not insert.
     return;
   }
 
   if (return_address != 0) {
     InsertAt(1, return_address);
   }
 }
 
-
 ProcessedSampleBuffer::ProcessedSampleBuffer()
     : code_lookup_table_(new CodeLookupTable(Thread::Current())) {
   ASSERT(code_lookup_table_ != NULL);
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart