clang-format runtime/vm

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 15 matching lines @@
 
 namespace dart {
 
 static const intptr_t kSampleSize = 8;
 static const intptr_t kMaxSamplesPerTick = 4;
 
 DEFINE_FLAG(bool, trace_profiled_isolates, false, "Trace profiled isolates.");
 
 #if defined(TARGET_OS_ANDROID) || defined(TARGET_ARCH_ARM64) ||                \
     defined(TARGET_ARCH_ARM) || defined(TARGET_ARCH_MIPS)
-  DEFINE_FLAG(int, profile_period, 10000,
-              "Time between profiler samples in microseconds. Minimum 50.");
+DEFINE_FLAG(int,
+            profile_period,
+            10000,
+            "Time between profiler samples in microseconds. Minimum 50.");
 #else
-  DEFINE_FLAG(int, profile_period, 1000,
-              "Time between profiler samples in microseconds. Minimum 50.");
+DEFINE_FLAG(int,
+            profile_period,
+            1000,
+            "Time between profiler samples in microseconds. Minimum 50.");
 #endif
-DEFINE_FLAG(int, max_profile_depth, kSampleSize * kMaxSamplesPerTick,
+DEFINE_FLAG(int,
+            max_profile_depth,
+            kSampleSize* kMaxSamplesPerTick,
             "Maximum number stack frames walked. Minimum 1. Maximum 255.");
 #if defined(USING_SIMULATOR)
-DEFINE_FLAG(bool, profile_vm, true,
-            "Always collect native stack traces.");
+DEFINE_FLAG(bool, profile_vm, true, "Always collect native stack traces.");
 #else
-DEFINE_FLAG(bool, profile_vm, false,
-            "Always collect native stack traces.");
+DEFINE_FLAG(bool, profile_vm, false, "Always collect native stack traces.");
 #endif
 
 #ifndef PRODUCT
 
 bool Profiler::initialized_ = false;
 SampleBuffer* Profiler::sample_buffer_ = NULL;
 ProfilerCounters Profiler::counters_;
 
 void Profiler::InitOnce() {
   // Place some sane restrictions on user controlled flags.
@@ skipping 46 matching lines @@
   }
 }
 
 
 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.
+  instance_size_ = sizeof(Sample) + (sizeof(uword) * pcs_length_);  // NOLINT.
 }
 
 
 uword* Sample::GetPCArray() const {
-  return reinterpret_cast<uword*>(
-        reinterpret_cast<uintptr_t>(this) + sizeof(*this));
+  return reinterpret_cast<uword*>(reinterpret_cast<uintptr_t>(this) +
+                                  sizeof(*this));
 }
 
 
 SampleBuffer::SampleBuffer(intptr_t capacity) {
   ASSERT(Sample::instance_size() > 0);
-  samples_ = reinterpret_cast<Sample*>(
-      calloc(capacity, Sample::instance_size()));
+  samples_ =
+      reinterpret_cast<Sample*>(calloc(capacity, Sample::instance_size()));
   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",
               capacity * Sample::instance_size());
   }
   capacity_ = capacity;
   cursor_ = 0;
 }
 
@@ skipping 46 matching lines @@
   }
 
   ReturnAddressLocator(uword pc, uword* stack_buffer, const Code& code)
       : stack_buffer_(stack_buffer),
         pc_(pc),
         code_(Code::ZoneHandle(code.raw())) {
     ASSERT(!code_.IsNull());
     ASSERT(code_.ContainsInstructionAt(pc_));
   }
 
-  uword pc() {
-    return pc_;
-  }
+  uword pc() { return pc_; }
 
   // Returns false on failure.
   bool LocateReturnAddress(uword* return_address);
 
   // Returns offset into code object.
   intptr_t RelativePC() {
     ASSERT(pc() >= code_.PayloadStart());
     return static_cast<intptr_t>(pc() - code_.PayloadStart());
   }
 
@@ skipping 86 matching lines @@
 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)) {
+  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());
   return (task & thread_task_mask_) != 0;
 }
 
 
 ClearProfileVisitor::ClearProfileVisitor(Isolate* isolate)
-    : SampleVisitor(isolate) {
-}
+    : SampleVisitor(isolate) {}
 
 
 void ClearProfileVisitor::VisitSample(Sample* sample) {
   sample->Clear();
 }
 
 
 static void DumpStackFrame(intptr_t frame_index, uword pc) {
   uintptr_t start = 0;
-  char* native_symbol_name =
-      NativeSymbolResolver::LookupSymbolName(pc, &start);
+  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);
   }
 }
 
 
-static void DumpStackFrame(intptr_t frame_index,
-                           uword pc,
-                           const Code& code) {
+static void DumpStackFrame(intptr_t frame_index, uword pc, const Code& code) {
   if (code.IsNull()) {
     DumpStackFrame(frame_index, pc);
   } else {
-    OS::PrintErr("Frame[%" Pd "] = Dart:`%s` [0x%" Px "]\n",
-                 frame_index, code.ToCString(), pc);
+    OS::PrintErr("Frame[%" Pd "] = Dart:`%s` [0x%" Px "]\n", frame_index,
+                 code.ToCString(), pc);
   }
 }
 
 
 class ProfilerStackWalker : public ValueObject {
  public:
   ProfilerStackWalker(Isolate* isolate,
                       Sample* head_sample,
                       SampleBuffer* sample_buffer)
-    : isolate_(isolate),
-      sample_(head_sample),
-      sample_buffer_(sample_buffer),
-      frame_index_(0),
-      total_frames_(0) {
+      : isolate_(isolate),
+        sample_(head_sample),
+        sample_buffer_(sample_buffer),
+        frame_index_(0),
+        total_frames_(0) {
     ASSERT(isolate_ != NULL);
     if (sample_ == NULL) {
       ASSERT(sample_buffer_ == NULL);
     } else {
       ASSERT(sample_buffer_ != NULL);
       ASSERT(sample_->head_sample());
     }
   }
 
   bool Append(uword pc, const Code& code) {
@@ skipping 45 matching lines @@
 
 
 // Given an exit frame, walk the Dart stack.
 class ProfilerDartExitStackWalker : public ProfilerStackWalker {
  public:
   ProfilerDartExitStackWalker(Thread* thread,
                               Isolate* isolate,
                               Sample* sample,
                               SampleBuffer* sample_buffer)
       : ProfilerStackWalker(isolate, sample, sample_buffer),
-        frame_iterator_(thread) {
-  }
+        frame_iterator_(thread) {}
 
   void walk() {
     // Mark that this sample was collected from an exit frame.
     sample_->set_exit_frame_sample(true);
 
     StackFrame* frame = frame_iterator_.NextFrame();
     if (sample_ == NULL) {
       // Only when we are dumping the stack trace for debug purposes.
       Code& code = Code::Handle();
       while (frame != NULL) {
@@ skipping 143 matching lines @@
 
   uword* ExitLink() const {
     ASSERT(fp_ != NULL);
     uword* exit_link_ptr = fp_ + kExitLinkSlotFromEntryFp;
     // MSan/ASan are unaware of frames initialized by generated code.
     MSAN_UNPOISON(exit_link_ptr, kWordSize);
     ASAN_UNPOISON(exit_link_ptr, kWordSize);
     return reinterpret_cast<uword*>(*exit_link_ptr);
   }
 
-  bool ValidFramePointer() const {
-    return ValidFramePointer(fp_);
-  }
+  bool ValidFramePointer() const { return ValidFramePointer(fp_); }
 
   bool ValidFramePointer(uword* fp) const {
     if (fp == NULL) {
       return false;
     }
     uword cursor = reinterpret_cast<uword>(fp);
     cursor += sizeof(fp);
     return (cursor >= stack_lower_) && (cursor < stack_upper_);
   }
 
@@ skipping 17 matching lines @@
                             uword stack_lower,
                             uword stack_upper,
                             uword pc,
                             uword fp,
                             uword sp)
       : ProfilerStackWalker(isolate, sample, sample_buffer),
         stack_upper_(stack_upper),
         original_pc_(pc),
         original_fp_(fp),
         original_sp_(sp),
-        lower_bound_(stack_lower) {
-  }
+        lower_bound_(stack_lower) {}
 
   void walk() {
     const uword kMaxStep = VirtualMemory::PageSize();
     Append(original_pc_);
 
     uword* pc = reinterpret_cast<uword*>(original_pc_);
     uword* fp = reinterpret_cast<uword*>(original_fp_);
     uword* previous_fp = fp;
 
     uword gap = original_fp_ - original_sp_;
@@ skipping 121 matching lines @@
                           uword pc,
                           uword fp,
                           uword sp,
                           ProfilerCounters* counters) {
   ASSERT(counters != NULL);
 #if defined(TARGET_OS_WINDOWS)
   // Use structured exception handling to trap guard page access on Windows.
   __try {
 #endif
 
-  if (in_dart_code) {
-    // We can only trust the stack pointer if we are executing Dart code.
-    // See http://dartbug.com/20421 for details.
-    CopyStackBuffer(sample, sp);
-  }
+    if (in_dart_code) {
+      // We can only trust the stack pointer if we are executing Dart code.
+      // See http://dartbug.com/20421 for details.
+      CopyStackBuffer(sample, sp);
+    }
 
-  if (FLAG_profile_vm) {
-    // Always walk the native stack collecting both native and Dart frames.
-    AtomicOperations::IncrementInt64By(&counters->stack_walker_native, 1);
-    native_stack_walker->walk();
-  } else if (StubCode::HasBeenInitialized() && exited_dart_code) {
-    AtomicOperations::IncrementInt64By(&counters->stack_walker_dart_exit, 1);
-    // We have a valid exit frame info, use the Dart stack walker.
-    dart_exit_stack_walker->walk();
-  } else if (StubCode::HasBeenInitialized() && in_dart_code) {
-    AtomicOperations::IncrementInt64By(&counters->stack_walker_dart, 1);
-    // We are executing Dart code. We have frame pointers.
-    dart_stack_walker->walk();
-  } else {
-    AtomicOperations::IncrementInt64By(&counters->stack_walker_none, 1);
-    sample->SetAt(0, pc);
-  }
+    if (FLAG_profile_vm) {
+      // Always walk the native stack collecting both native and Dart frames.
+      AtomicOperations::IncrementInt64By(&counters->stack_walker_native, 1);
+      native_stack_walker->walk();
+    } else if (StubCode::HasBeenInitialized() && exited_dart_code) {
+      AtomicOperations::IncrementInt64By(&counters->stack_walker_dart_exit, 1);
+      // We have a valid exit frame info, use the Dart stack walker.
+      dart_exit_stack_walker->walk();
+    } else if (StubCode::HasBeenInitialized() && in_dart_code) {
+      AtomicOperations::IncrementInt64By(&counters->stack_walker_dart, 1);
+      // We are executing Dart code. We have frame pointers.
+      dart_stack_walker->walk();
+    } else {
+      AtomicOperations::IncrementInt64By(&counters->stack_walker_none, 1);
+      sample->SetAt(0, pc);
+    }
 
 #if defined(TARGET_OS_WINDOWS)
-  // Use structured exception handling to trap guard page access.
-  } __except(GuardPageExceptionFilter(GetExceptionInformation())) {
+    // Use structured exception handling to trap guard page access.
+  } __except (GuardPageExceptionFilter(GetExceptionInformation())) {  // NOLINT
     // Sample collection triggered a guard page fault:
     // 1) discard entire sample.
     sample->set_ignore_sample(true);
 
     // 2) Reenable guard bit on page that triggered the fault.
     // https://goo.gl/5mCsXW
     DWORD new_protect = PAGE_READWRITE | PAGE_GUARD;
     DWORD old_protect = 0;
-    BOOL success = VirtualProtect(reinterpret_cast<void*>(fault_address),
-                                  sizeof(fault_address),
-                                  new_protect,
-                                  &old_protect);
+    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
 }
 
 
 // Get |isolate|'s stack boundary and verify that |sp| and |fp| are within
 // it. Return |false| if anything looks suspicious.
@@ skipping 106 matching lines @@
 static bool CheckIsolate(Isolate* isolate) {
   if ((isolate == NULL) || (Dart::vm_isolate() == NULL)) {
     // No isolate.
     return false;
   }
   return isolate != Dart::vm_isolate();
 }
 
 
 #if defined(TARGET_OS_WINDOWS)
-__declspec(noinline)
-static uintptr_t GetProgramCounter() {
+__declspec(noinline) static uintptr_t GetProgramCounter() {
   return reinterpret_cast<uintptr_t>(_ReturnAddress());
 }
 #else
 static uintptr_t __attribute__((noinline)) GetProgramCounter() {
   return reinterpret_cast<uintptr_t>(
       __builtin_extract_return_addr(__builtin_return_address(0)));
 }
 #endif
 
 
@@ skipping 26 matching lines @@
   uintptr_t sp = Thread::GetCurrentStackPointer();
   uintptr_t fp = 0;
   uintptr_t pc = GetProgramCounter();
 
   COPY_FP_REGISTER(fp);
 
   uword stack_lower = 0;
   uword stack_upper = 0;
 
   if (!InitialRegisterCheck(pc, fp, sp)) {
-    OS::PrintErr(
-        "Stack dump aborted because InitialRegisterCheck.\n");
+    OS::PrintErr("Stack dump aborted because InitialRegisterCheck.\n");
     return;
   }
 
-  if (!GetAndValidateIsolateStackBounds(thread,
-                                        fp,
-                                        sp,
-                                        &stack_lower,
+  if (!GetAndValidateIsolateStackBounds(thread, fp, sp, &stack_lower,
                                         &stack_upper)) {
     OS::PrintErr(
         "Stack dump aborted because GetAndValidateIsolateStackBounds.\n");
     return;
   }
 
   if (native_stack_trace) {
-    ProfilerNativeStackWalker native_stack_walker(isolate,
-                                                  NULL,
-                                                  NULL,
-                                                  stack_lower,
-                                                  stack_upper,
-                                                  pc,
-                                                  fp,
-                                                  sp);
+    ProfilerNativeStackWalker native_stack_walker(
+        isolate, NULL, NULL, stack_lower, stack_upper, pc, fp, sp);
     native_stack_walker.walk();
   } else if (exited_dart_code) {
-    ProfilerDartExitStackWalker dart_exit_stack_walker(thread,
-                                                       isolate,
-                                                       NULL,
+    ProfilerDartExitStackWalker dart_exit_stack_walker(thread, isolate, NULL,
                                                        NULL);
     dart_exit_stack_walker.walk();
   } else {
-    ProfilerDartStackWalker dart_stack_walker(isolate,
-                                              NULL,
-                                              NULL,
-                                              stack_lower,
-                                              stack_upper,
-                                              pc,
-                                              fp,
-                                              sp);
+    ProfilerDartStackWalker dart_stack_walker(isolate, NULL, NULL, stack_lower,
+                                              stack_upper, pc, fp, sp);
   }
   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();
@@ skipping 16 matching lines @@
 
     COPY_FP_REGISTER(fp);
 
     uword stack_lower = 0;
     uword stack_upper = 0;
 
     if (!InitialRegisterCheck(pc, fp, sp)) {
       return;
     }
 
-    if (!GetAndValidateIsolateStackBounds(thread,
-                                          fp,
-                                          sp,
-                                          &stack_lower,
+    if (!GetAndValidateIsolateStackBounds(thread, fp, sp, &stack_lower,
                                           &stack_upper)) {
       // Could not get stack boundary.
       return;
     }
 
     Sample* sample = SetupSample(thread, sample_buffer, os_thread->trace_id());
     sample->SetAllocationCid(cid);
-    ProfilerNativeStackWalker native_stack_walker(isolate,
-                                                  sample,
-                                                  sample_buffer,
-                                                  stack_lower,
-                                                  stack_upper,
-                                                  pc,
-                                                  fp,
-                                                  sp);
+    ProfilerNativeStackWalker native_stack_walker(
+        isolate, sample, sample_buffer, stack_lower, stack_upper, pc, fp, sp);
     native_stack_walker.walk();
   } else if (exited_dart_code) {
     Sample* sample = SetupSample(thread, sample_buffer, os_thread->trace_id());
     sample->SetAllocationCid(cid);
-    ProfilerDartExitStackWalker dart_exit_stack_walker(thread,
-                                                       isolate,
-                                                       sample,
+    ProfilerDartExitStackWalker dart_exit_stack_walker(thread, isolate, sample,
                                                        sample_buffer);
     dart_exit_stack_walker.walk();
   } else {
     // Fall back.
     uintptr_t pc = GetProgramCounter();
     Sample* sample = SetupSample(thread, sample_buffer, os_thread->trace_id());
     sample->SetAllocationCid(cid);
     sample->SetAt(0, pc);
   }
 }
@@ skipping 51 matching lines @@
   const bool in_dart_code = thread->IsExecutingDartCode();
 
   uintptr_t sp = 0;
   uintptr_t fp = state.fp;
   uintptr_t pc = state.pc;
 #if defined(USING_SIMULATOR)
   Simulator* simulator = NULL;
 #endif
 
   if (in_dart_code) {
-    // If we're in Dart code, use the Dart stack pointer.
+// If we're in Dart code, use the Dart stack pointer.
 #if defined(TARGET_ARCH_DBC)
     simulator = isolate->simulator();
     sp = simulator->get_sp();
     fp = simulator->get_fp();
     pc = simulator->get_pc();
 #elif defined(USING_SIMULATOR)
     simulator = isolate->simulator();
     sp = simulator->get_register(SPREG);
     fp = simulator->get_register(FPREG);
     pc = simulator->get_pc();
@@ skipping 19 matching lines @@
 
   if (!InitialRegisterCheck(pc, fp, sp)) {
     AtomicOperations::IncrementInt64By(
         &counters_.single_frame_sample_register_check, 1);
     SampleThreadSingleFrame(thread, pc);
     return;
   }
 
   uword stack_lower = 0;
   uword stack_upper = 0;
-  if (!GetAndValidateIsolateStackBounds(thread,
-                                        fp,
-                                        sp,
-                                        &stack_lower,
+  if (!GetAndValidateIsolateStackBounds(thread, fp, sp, &stack_lower,
                                         &stack_upper)) {
     AtomicOperations::IncrementInt64By(
-       &counters_.single_frame_sample_get_and_validate_stack_bounds, 1);
+        &counters_.single_frame_sample_get_and_validate_stack_bounds, 1);
     // Could not get stack boundary.
     SampleThreadSingleFrame(thread, pc);
     return;
   }
 
   // At this point we have a valid stack boundary for this isolate and
   // know that our initial stack and frame pointers are within the boundary.
   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());
   }
 
-  ProfilerNativeStackWalker native_stack_walker(isolate,
-                                                sample,
-                                                sample_buffer,
-                                                stack_lower,
-                                                stack_upper,
-                                                pc,
-                                                fp,
-                                                sp);
+  ProfilerNativeStackWalker native_stack_walker(
+      isolate, sample, sample_buffer, stack_lower, stack_upper, pc, fp, sp);
 
-  ProfilerDartExitStackWalker dart_exit_stack_walker(thread,
-                                                     isolate,
-                                                     sample,
+  ProfilerDartExitStackWalker dart_exit_stack_walker(thread, isolate, sample,
                                                      sample_buffer);
 
-  ProfilerDartStackWalker dart_stack_walker(isolate,
-                                            sample,
-                                            sample_buffer,
-                                            stack_lower,
-                                            stack_upper,
-                                            pc,
-                                            fp,
-                                            sp);
+  ProfilerDartStackWalker dart_stack_walker(
+      isolate, sample, sample_buffer, stack_lower, stack_upper, pc, fp, sp);
 
   const bool exited_dart_code = thread->HasExitedDartCode();
 
   // All memory access is done inside CollectSample.
-  CollectSample(isolate,
-                exited_dart_code,
-                in_dart_code,
-                sample,
-                &native_stack_walker,
-                &dart_exit_stack_walker,
-                &dart_stack_walker,
-                pc,
-                fp,
-                sp,
-                &counters_);
+  CollectSample(isolate, exited_dart_code, in_dart_code, sample,
+                &native_stack_walker, &dart_exit_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();
 }
 
 
@@ skipping 11 matching lines @@
   Build(thread);
 }
 
 
 class CodeLookupTableBuilder : public ObjectVisitor {
  public:
   explicit CodeLookupTableBuilder(CodeLookupTable* table) : table_(table) {
     ASSERT(table_ != NULL);
   }
 
-  ~CodeLookupTableBuilder() {
-  }
+  ~CodeLookupTableBuilder() {}
 
   void VisitObject(RawObject* raw_obj) {
     uword 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());
@@ skipping 82 matching lines @@
   return NULL;
 }
 
 
 ProcessedSampleBuffer* SampleBuffer::BuildProcessedSampleBuffer(
     SampleFilter* filter) {
   ASSERT(filter != NULL);
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
 
-  ProcessedSampleBuffer* buffer = new(zone) ProcessedSampleBuffer();
+  ProcessedSampleBuffer* buffer = new (zone) ProcessedSampleBuffer();
 
   const intptr_t length = capacity();
   for (intptr_t i = 0; i < length; i++) {
     Sample* sample = At(i);
     if (sample->ignore_sample()) {
       // Bad sample.
       continue;
     }
     if (!sample->head_sample()) {
       // An inner sample in a chain of samples.
@@ skipping 28 matching lines @@
   return buffer;
 }
 
 
 ProcessedSample* SampleBuffer::BuildProcessedSample(
     Sample* sample,
     const CodeLookupTable& clt) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
 
-  ProcessedSample* processed_sample = new(zone) ProcessedSample();
+  ProcessedSample* processed_sample = new (zone) ProcessedSample();
 
   // Copy state bits from sample.
   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).
   bool truncated = false;
   Sample* current = sample;
   while (current != NULL) {
     for (intptr_t i = 0; i < kSampleSize; i++) {
       if (current->At(i) == 0) {
         break;
       }
       processed_sample->Add(current->At(i));
     }
 
     truncated = truncated || current->truncated_trace();
     current = Next(current);
   }
 
   if (!sample->exit_frame_sample()) {
-    processed_sample->FixupCaller(clt,
-                                  sample->pc_marker(),
+    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;
+  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->isolate() != next_sample->isolate()) {
     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) {
-}
+      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;
   }
@@ skipping 61 matching lines @@
 
 
 ProcessedSampleBuffer::ProcessedSampleBuffer()
     : code_lookup_table_(new CodeLookupTable(Thread::Current())) {
   ASSERT(code_lookup_table_ != NULL);
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart