clang-format runtime/vm

runtime/vm/profiler_service.cc

 // Copyright (c) 2015, 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 "vm/profiler_service.h"
 
 #include "vm/growable_array.h"
 #include "vm/hash_map.h"
 #include "vm/log.h"
 #include "vm/native_symbol.h"
@@ skipping 11 matching lines @@
 DECLARE_FLAG(bool, profile_vm);
 
 #ifndef PRODUCT
 
 class DeoptimizedCodeSet : public ZoneAllocated {
  public:
   explicit DeoptimizedCodeSet(Isolate* isolate)
       : previous_(
             GrowableObjectArray::ZoneHandle(isolate->deoptimized_code_array())),
         current_(GrowableObjectArray::ZoneHandle(
-            previous_.IsNull() ? GrowableObjectArray::null() :
-                                 GrowableObjectArray::New())) {
-  }
+            previous_.IsNull() ? GrowableObjectArray::null()
+                               : GrowableObjectArray::New())) {}
 
   void Add(const Code& code) {
     if (current_.IsNull()) {
       return;
     }
     if (!Contained(code, previous_) || Contained(code, current_)) {
       return;
     }
     current_.Add(code);
   }
 
   void UpdateIsolate(Isolate* isolate) {
     intptr_t size_before = SizeOf(previous_);
     intptr_t size_after = SizeOf(current_);
     if ((size_before > 0) && FLAG_trace_profiler) {
       intptr_t length_before = previous_.Length();
       intptr_t length_after = current_.Length();
-      OS::Print("Updating isolate deoptimized code array: "
-                "%" Pd " -> %" Pd " [%" Pd " -> %" Pd "]\n",
-                size_before, size_after, length_before, length_after);
+      OS::Print(
+          "Updating isolate deoptimized code array: "
+          "%" Pd " -> %" Pd " [%" Pd " -> %" Pd "]\n",
+          size_before, size_after, length_before, length_after);
     }
     isolate->set_deoptimized_code_array(current_);
   }
 
  private:
   bool Contained(const Code& code, const GrowableObjectArray& array) {
     if (array.IsNull() || code.IsNull()) {
       return false;
     }
     NoSafepointScope no_safepoint_scope;
@@ skipping 21 matching lines @@
 
   // Array holding code that is being kept around only for the profiler.
   const GrowableObjectArray& previous_;
   // Array holding code that should continue to be kept around for the profiler.
   const GrowableObjectArray& current_;
 };
 
 
 ProfileFunctionSourcePosition::ProfileFunctionSourcePosition(
     TokenPosition token_pos)
-    : token_pos_(token_pos),
-      exclusive_ticks_(0),
-      inclusive_ticks_(0) {
-}
+    : token_pos_(token_pos), exclusive_ticks_(0), inclusive_ticks_(0) {}
 
 
 void ProfileFunctionSourcePosition::Tick(bool exclusive) {
   if (exclusive) {
     exclusive_ticks_++;
   } else {
     inclusive_ticks_++;
   }
 }
 
 
 ProfileFunction::ProfileFunction(Kind kind,
-                  const char* name,
-                  const Function& function,
-                  const intptr_t table_index)
+                                 const char* name,
+                                 const Function& function,
+                                 const intptr_t table_index)
     : kind_(kind),
       name_(name),
       function_(Function::ZoneHandle(function.raw())),
       table_index_(table_index),
       profile_codes_(0),
       source_position_ticks_(0),
       exclusive_ticks_(0),
       inclusive_ticks_(0),
       inclusive_serial_(-1) {
   ASSERT((kind_ != kDartFunction) || !function_.IsNull());
@@ skipping 141 matching lines @@
   }
   if (source_position_ticks_.length() != 1) {
     return false;
   }
   *pfsp = source_position_ticks_[0];
   return true;
 }
 
 
 ProfileCodeAddress::ProfileCodeAddress(uword pc)
-    : pc_(pc),
-      exclusive_ticks_(0),
-      inclusive_ticks_(0) {
-}
+    : pc_(pc), exclusive_ticks_(0), inclusive_ticks_(0) {}
 
 
 void ProfileCodeAddress::Tick(bool exclusive) {
   if (exclusive) {
     exclusive_ticks_++;
   } else {
     inclusive_ticks_++;
   }
 }
 
 
 ProfileCode::ProfileCode(Kind kind,
                          uword start,
                          uword end,
                          int64_t timestamp,
                          const Code& code)
     : kind_(kind),
       start_(start),
       end_(end),
       exclusive_ticks_(0),
       inclusive_ticks_(0),
       inclusive_serial_(-1),
       code_(code),
       name_(NULL),
       compile_timestamp_(0),
       function_(NULL),
       code_table_index_(-1),
-      address_ticks_(0) {
-}
+      address_ticks_(0) {}
 
 
 void ProfileCode::AdjustExtent(uword start, uword end) {
   if (start < start_) {
     start_ = start;
   }
   if (end > end_) {
     end_ = end;
   }
   ASSERT(start_ < end_);
 }
 
 
 bool ProfileCode::Overlaps(const ProfileCode* other) const {
   ASSERT(other != NULL);
-  return other->Contains(start_)   ||
-         other->Contains(end_ - 1) ||
-         Contains(other->start())  ||
-         Contains(other->end() - 1);
+  return other->Contains(start_) || other->Contains(end_ - 1) ||
+         Contains(other->start()) || Contains(other->end() - 1);
 }
 
 
 bool ProfileCode::IsOptimizedDart() const {
   return !code_.IsNull() && code_.is_optimized();
 }
 
 
 void ProfileCode::SetName(const char* name) {
   if (name == NULL) {
     name_ = NULL;
   }
   intptr_t len = strlen(name);
   name_ = Thread::Current()->zone()->Alloc<char>(len + 1);
   strncpy(name_, name, len);
   name_[len] = '\0';
 }
 
 
 void ProfileCode::GenerateAndSetSymbolName(const char* prefix) {
   const intptr_t kBuffSize = 512;
   char buff[kBuffSize];
-  OS::SNPrint(&buff[0], kBuffSize-1, "%s [%" Px ", %" Px ")",
-              prefix, start(), end());
+  OS::SNPrint(&buff[0], kBuffSize - 1, "%s [%" Px ", %" Px ")", prefix, start(),
+              end());
   SetName(buff);
 }
 
 
 void ProfileCode::Tick(uword pc, bool exclusive, intptr_t serial) {
   // If exclusive is set, tick it.
   if (exclusive) {
     exclusive_ticks_++;
     TickAddress(pc, true);
   }
@@ skipping 158 matching lines @@
   }
 }
 
 
 class ProfileFunctionTable : public ZoneAllocated {
  public:
   ProfileFunctionTable()
       : null_function_(Function::ZoneHandle()),
         unknown_function_(NULL),
         table_(8) {
-    unknown_function_ = Add(ProfileFunction::kUnknownFunction,
-                            "<unknown Dart function>");
+    unknown_function_ =
+        Add(ProfileFunction::kUnknownFunction, "<unknown Dart function>");
   }
 
   ProfileFunction* LookupOrAdd(const Function& function) {
     ASSERT(!function.IsNull());
     ProfileFunction* profile_function = Lookup(function);
     if (profile_function != NULL) {
       return profile_function;
     }
     return Add(function);
   }
@@ skipping 19 matching lines @@
   ProfileFunction* AddNative(uword start_address, const char* name) {
     // TODO(johnmccutchan): Canonicalize ProfileFunctions for natives.
     return Add(ProfileFunction::kNativeFunction, name);
   }
 
   // No protection against being called more tha once for the same stub.
   ProfileFunction* AddStub(uword start_address, const char* name) {
     return Add(ProfileFunction::kStubFunction, name);
   }
 
-  intptr_t length() const {
-    return table_.length();
-  }
+  intptr_t length() const { return table_.length(); }
 
   ProfileFunction* At(intptr_t i) const {
     ASSERT(i >= 0);
     ASSERT(i < length());
     return table_[i];
   }
 
  private:
   ProfileFunction* Add(ProfileFunction::Kind kind, const char* name) {
     ASSERT(kind != ProfileFunction::kDartFunction);
     ASSERT(name != NULL);
     ProfileFunction* profile_function =
-        new ProfileFunction(kind,
-                            name,
-                            null_function_,
-                            table_.length());
+        new ProfileFunction(kind, name, null_function_, table_.length());
     table_.Add(profile_function);
     return profile_function;
   }
 
   ProfileFunction* Add(const Function& function) {
     ASSERT(Lookup(function) == NULL);
-    ProfileFunction* profile_function =
-        new ProfileFunction(ProfileFunction::kDartFunction,
-                            NULL,
-                            function,
-                            table_.length());
+    ProfileFunction* profile_function = new ProfileFunction(
+        ProfileFunction::kDartFunction, NULL, function, table_.length());
     table_.Add(profile_function);
     function_hash_.Insert(profile_function);
     return profile_function;
   }
 
   // Needed for DirectChainedHashMap.
   struct ProfileFunctionTableTrait {
     typedef ProfileFunction* Value;
     typedef const Function* Key;
     typedef ProfileFunction* Pair;
 
-    static Key KeyOf(Pair kv) {
-      return kv->function();
-    }
+    static Key KeyOf(Pair kv) { return kv->function(); }
 
-    static Value ValueOf(Pair kv) {
-      return kv;
-    }
+    static Value ValueOf(Pair kv) { return kv; }
 
-    static inline intptr_t Hashcode(Key key) {
-      return key->Hash();
-    }
+    static inline intptr_t Hashcode(Key key) { return key->Hash(); }
 
     static inline bool IsKeyEqual(Pair kv, Key key) {
       return kv->function()->raw() == key->raw();
     }
   };
 
   const Function& null_function_;
   ProfileFunction* unknown_function_;
   ZoneGrowableArray<ProfileFunction*> table_;
   DirectChainedHashMap<ProfileFunctionTableTrait> function_hash_;
@@ skipping 27 matching lines @@
       // Lazily set generated name.
       GenerateAndSetSymbolName("[Native]");
     }
     function = table->AddNative(start(), name());
   } else if (kind() == kTagCode) {
     if (name() == NULL) {
       if (UserTags::IsUserTag(start())) {
         const char* tag_name = UserTags::TagName(start());
         ASSERT(tag_name != NULL);
         SetName(tag_name);
-      } else if (VMTag::IsVMTag(start()) ||
-                 VMTag::IsRuntimeEntryTag(start()) ||
+      } else if (VMTag::IsVMTag(start()) || VMTag::IsRuntimeEntryTag(start()) ||
                  VMTag::IsNativeEntryTag(start())) {
         const char* tag_name = VMTag::TagName(start());
         ASSERT(tag_name != NULL);
         SetName(tag_name);
       } else {
         switch (start()) {
           case VMTag::kRootTagId:
             SetName("Root");
             break;
           case VMTag::kTruncatedTagId:
@@ skipping 12 matching lines @@
             SetName("[Native Code]");
             break;
           case VMTag::kInlineStartCodeTagId:
             SetName("[Inline Start]");
             break;
           case VMTag::kInlineEndCodeTagId:
             SetName("[Inline End]");
             break;
           default:
             UNIMPLEMENTED();
-          break;
+            break;
         }
       }
     }
     function = table->AddTag(start(), name());
   } else {
     UNREACHABLE();
   }
   ASSERT(function != NULL);
 
   function->AddProfileCode(code_table_index());
 
   function_ = function;
   return function_;
 }
 
 
 typedef bool (*RangeCompare)(uword pc, uword region_start, uword region_end);
 
 class ProfileCodeTable : public ZoneAllocated {
  public:
-  ProfileCodeTable()
-      : table_(8) {
-  }
+  ProfileCodeTable() : table_(8) {}
 
   intptr_t length() const { return table_.length(); }
 
   ProfileCode* At(intptr_t index) const {
     ASSERT(index >= 0);
     ASSERT(index < length());
     return table_[index];
   }
 
   // Find the table index to the ProfileCode containing pc.
@@ skipping 101 matching lines @@
   }
 
   static bool CompareUpperBound(uword pc, uword start, uword end) {
     return pc >= end;
   }
 
   static bool CompareLowerBound(uword pc, uword start, uword end) {
     return end <= pc;
   }
 
-  void HandleOverlap(ProfileCode* existing, ProfileCode* code,
-                     uword start, uword end) {
+  void HandleOverlap(ProfileCode* existing,
+                     ProfileCode* code,
+                     uword start,
+                     uword end) {
     // We should never see overlapping Dart code regions.
     ASSERT(existing->kind() != ProfileCode::kDartCode);
     // We should never see overlapping Tag code regions.
     ASSERT(existing->kind() != ProfileCode::kTagCode);
     // When code regions overlap, they should be of the same kind.
     ASSERT(existing->kind() == code->kind());
     existing->AdjustExtent(start, end);
   }
 
   void VerifyOrder() {
     const intptr_t length = table_.length();
     if (length == 0) {
       return;
     }
     uword last = table_[0]->end();
     for (intptr_t i = 1; i < length; i++) {
       ProfileCode* a = table_[i];
       ASSERT(last <= a->start());
       last = a->end();
     }
   }
 
   void VerifyOverlap() {
     const intptr_t length = table_.length();
     for (intptr_t i = 0; i < length; i++) {
       ProfileCode* a = table_[i];
-      for (intptr_t j = i+1; j < length; j++) {
+      for (intptr_t j = i + 1; j < length; j++) {
         ProfileCode* b = table_[j];
-        ASSERT(!a->Contains(b->start()) &&
-               !a->Contains(b->end() - 1) &&
-               !b->Contains(a->start()) &&
-               !b->Contains(a->end() - 1));
+        ASSERT(!a->Contains(b->start()) && !a->Contains(b->end() - 1) &&
+               !b->Contains(a->start()) && !b->Contains(a->end() - 1));
       }
     }
   }
 
   ZoneGrowableArray<ProfileCode*> table_;
 };
 
 
 ProfileTrieNode::ProfileTrieNode(intptr_t table_index)
-    : table_index_(table_index),
-      count_(0),
-      children_(0),
-      frame_id_(-1) {
+    : table_index_(table_index), count_(0), children_(0), frame_id_(-1) {
   ASSERT(table_index_ >= 0);
 }
 
 
-ProfileTrieNode::~ProfileTrieNode() {
-}
+ProfileTrieNode::~ProfileTrieNode() {}
 
 
 void ProfileTrieNode::SortChildren() {
   children_.Sort(ProfileTrieNodeCompare);
   // Recurse.
   for (intptr_t i = 0; i < children_.length(); i++) {
     children_[i]->SortChildren();
   }
 }
 
 
 intptr_t ProfileTrieNode::IndexOf(ProfileTrieNode* node) {
   for (intptr_t i = 0; i < children_.length(); i++) {
     if (children_[i] == node) {
       return i;
     }
   }
   return -1;
 }
 
 
 class ProfileCodeTrieNode : public ProfileTrieNode {
  public:
   explicit ProfileCodeTrieNode(intptr_t table_index)
-      : ProfileTrieNode(table_index) {
-  }
+      : ProfileTrieNode(table_index) {}
 
   void PrintToJSONArray(JSONArray* array) const {
     ASSERT(array != NULL);
     // Write CodeRegion index.
     array->AddValue(table_index());
     // Write count.
     array->AddValue(count());
     // Write number of children.
     intptr_t child_count = NumChildren();
     array->AddValue(child_count);
@@ skipping 26 matching lines @@
       children_.Add(reinterpret_cast<ProfileTrieNode*>(child));
     }
     return child;
   }
 };
 
 
 class ProfileFunctionTrieNodeCode {
  public:
   explicit ProfileFunctionTrieNodeCode(intptr_t index)
-      : code_index_(index),
-        ticks_(0) {
-  }
+      : code_index_(index), ticks_(0) {}
 
-  intptr_t index() const {
-    return code_index_;
-  }
+  intptr_t index() const { return code_index_; }
 
-  void Tick() {
-    ticks_++;
-  }
+  void Tick() { ticks_++; }
 
-  intptr_t ticks() const {
-    return ticks_;
-  }
+  intptr_t ticks() const { return ticks_; }
 
  private:
   intptr_t code_index_;
   intptr_t ticks_;
 };
 
 
 class ProfileFunctionTrieNode : public ProfileTrieNode {
  public:
   explicit ProfileFunctionTrieNode(intptr_t table_index)
-      : ProfileTrieNode(table_index),
-        code_objects_(1) {
-  }
+      : ProfileTrieNode(table_index), code_objects_(1) {}
 
   void PrintToJSONArray(JSONArray* array) const {
     ASSERT(array != NULL);
     // Write CodeRegion index.
     array->AddValue(table_index());
     // Write count.
     array->AddValue(count());
     // Write number of code objects.
     intptr_t code_count = code_objects_.length();
     array->AddValue(code_count);
@@ skipping 50 matching lines @@
     code_objects_.Add(code_object);
   }
 
  private:
   ZoneGrowableArray<ProfileFunctionTrieNodeCode> code_objects_;
 };
 
 
 class ProfileCodeInlinedFunctionsCache : public ValueObject {
  public:
-  ProfileCodeInlinedFunctionsCache()
-      : cache_cursor_(0),
-        last_hit_(0) {
+  ProfileCodeInlinedFunctionsCache() : cache_cursor_(0), last_hit_(0) {
     for (intptr_t i = 0; i < kCacheSize; i++) {
       cache_[i].Reset();
     }
     cache_hit_ = 0;
     cache_miss_ = 0;
   }
 
   ~ProfileCodeInlinedFunctionsCache() {
     if (FLAG_trace_profiler) {
       intptr_t total = cache_hit_ + cache_miss_;
-      OS::Print("LOOKUPS: %" Pd " HITS: %" Pd " MISSES: %" Pd "\n",
-                total,
-                cache_hit_,
-                cache_miss_);
+      OS::Print("LOOKUPS: %" Pd " HITS: %" Pd " MISSES: %" Pd "\n", total,
+                cache_hit_, cache_miss_);
     }
   }
 
   void Get(uword pc,
            const Code& code,
            ProcessedSample* sample,
            intptr_t frame_index,
            // Outputs:
            GrowableArray<Function*>** inlined_functions,
            GrowableArray<TokenPosition>** inlined_token_positions,
            TokenPosition* token_position) {
     const intptr_t offset = OffsetForPC(pc, code, sample, frame_index);
-    if (FindInCache(pc,
-                    offset,
-                    inlined_functions,
-                    inlined_token_positions,
+    if (FindInCache(pc, offset, inlined_functions, inlined_token_positions,
                     token_position)) {
       // Found in cache.
       return;
     }
-    Add(pc, code, sample, frame_index,
-        inlined_functions, inlined_token_positions, token_position);
+    Add(pc, code, sample, frame_index, inlined_functions,
+        inlined_token_positions, token_position);
   }
 
  private:
   bool FindInCache(uword pc,
                    intptr_t offset,
                    GrowableArray<Function*>** inlined_functions,
                    GrowableArray<TokenPosition>** inlined_token_positions,
                    TokenPosition* token_position) {
     // Simple linear scan.
     for (intptr_t i = 0; i < kCacheSize; i++) {
@@ skipping 23 matching lines @@
            ProcessedSample* sample,
            intptr_t frame_index,
            // Outputs:
            GrowableArray<Function*>** inlined_functions,
            GrowableArray<TokenPosition>** inlined_token_positions,
            TokenPosition* token_position) {
     const intptr_t offset = OffsetForPC(pc, code, sample, frame_index);
     CacheEntry* cache_entry = &cache_[NextFreeIndex()];
     cache_entry->pc = pc;
     cache_entry->offset = offset;
-    code.GetInlinedFunctionsAt(offset,
-                               &(cache_entry->inlined_functions),
+    code.GetInlinedFunctionsAt(offset, &(cache_entry->inlined_functions),
                                &(cache_entry->inlined_token_positions));
     cache_entry->token_position = code.GetTokenPositionAt(offset);
     *token_position = (cache_entry->token_position);
     if (cache_entry->inlined_functions.length() == 0) {
       *inlined_functions = NULL;
       *inlined_token_positions = NULL;
       return;
     }
     // The inlined token position table does not include the token position
     // of the final call. Insert it at the beginning because the table.
     // is reversed.
-    cache_entry->inlined_token_positions.InsertAt(
-        0,
-        cache_entry->token_position);
+    cache_entry->inlined_token_positions.InsertAt(0,
+                                                  cache_entry->token_position);
 
     // Write outputs.
     *inlined_functions = &(cache_entry->inlined_functions);
     *inlined_token_positions = &(cache_entry->inlined_token_positions);
   }
 
   intptr_t NextFreeIndex() {
     cache_cursor_ = (cache_cursor_ + 1) % kCacheSize;
     return cache_cursor_;
   }
@@ skipping 88 matching lines @@
     BuildCodeTrie(Profile::kExclusiveCode);
     BuildCodeTrie(Profile::kInclusiveCode);
 
     BuildFunctionTrie(Profile::kExclusiveFunction);
     BuildFunctionTrie(Profile::kInclusiveFunction);
   }
 
  private:
   // Returns true if |frame_index| in |sample| is using CPU.
   static bool IsExecutingFrame(ProcessedSample* sample, intptr_t frame_index) {
-    return (frame_index == 0) && (sample->first_frame_executing() ||
-                                  sample->IsAllocationSample());
+    return (frame_index == 0) &&
+           (sample->first_frame_executing() || sample->IsAllocationSample());
   }
 
   static bool IsInclusiveTrie(Profile::TrieKind kind) {
     return (kind == Profile::kInclusiveFunction) ||
            (kind == Profile::kInclusiveCode);
   }
 
   void Setup() {
     profile_->live_code_ = new ProfileCodeTable();
     profile_->dead_code_ = new ProfileCodeTable();
@@ skipping 43 matching lines @@
     ASSERT(isolate != NULL);
 
     // Build the live code table eagerly by populating it with code objects
     // from the processed sample buffer.
     const CodeLookupTable& code_lookup_table = samples_->code_lookup_table();
     for (intptr_t i = 0; i < code_lookup_table.length(); i++) {
       const CodeDescriptor* descriptor = code_lookup_table.At(i);
       ASSERT(descriptor != NULL);
       const Code& code = Code::Handle(descriptor->code());
       ASSERT(!code.IsNull());
-      RegisterLiveProfileCode(
-          new ProfileCode(ProfileCode::kDartCode,
-                          code.PayloadStart(),
-                          code.PayloadStart() + code.Size(),
-                          code.compile_timestamp(),
-                          code));
+      RegisterLiveProfileCode(new ProfileCode(
+          ProfileCode::kDartCode, code.PayloadStart(),
+          code.PayloadStart() + code.Size(), code.compile_timestamp(), code));
     }
 
     // Iterate over samples.
-    for (intptr_t sample_index = 0;
-         sample_index < samples_->length();
+    for (intptr_t sample_index = 0; sample_index < samples_->length();
          sample_index++) {
       ProcessedSample* sample = samples_->At(sample_index);
       const int64_t timestamp = sample->timestamp();
 
       // This is our first pass over the sample buffer, use this as an
       // opportunity to determine the min and max time ranges of this profile.
       UpdateMinMaxTimes(timestamp);
 
       // Make sure VM tag exists.
       if (VMTag::IsNativeEntryTag(sample->vm_tag())) {
         RegisterProfileCodeTag(VMTag::kNativeTagId);
       } else if (VMTag::IsRuntimeEntryTag(sample->vm_tag())) {
         RegisterProfileCodeTag(VMTag::kRuntimeTagId);
       }
       RegisterProfileCodeTag(sample->vm_tag());
       // Make sure user tag exists.
       RegisterProfileCodeTag(sample->user_tag());
 
       // Make sure that a ProfileCode objects exist for all pcs in the sample
       // and tick each one.
-      for (intptr_t frame_index = 0;
-           frame_index < sample->length();
+      for (intptr_t frame_index = 0; frame_index < sample->length();
            frame_index++) {
         const uword pc = sample->At(frame_index);
         ASSERT(pc != 0);
         ProfileCode* code = FindOrRegisterProfileCode(pc, timestamp);
         ASSERT(code != NULL);
         code->Tick(pc, IsExecutingFrame(sample, frame_index), sample_index);
       }
 
       TickExitFrame(sample->vm_tag(), sample_index);
     }
@@ skipping 68 matching lines @@
     } else {
       BuildExclusiveCodeTrie(root);
     }
     root->SortChildren();
     profile_->roots_[static_cast<intptr_t>(kind)] = root;
   }
 
   void BuildInclusiveCodeTrie(ProfileCodeTrieNode* root) {
     ScopeTimer sw("ProfileBuilder::BuildInclusiveCodeTrie",
                   FLAG_trace_profiler);
-    for (intptr_t sample_index = 0;
-         sample_index < samples_->length();
+    for (intptr_t sample_index = 0; sample_index < samples_->length();
          sample_index++) {
       ProcessedSample* sample = samples_->At(sample_index);
 
       // Tick the root.
       ProfileCodeTrieNode* current = root;
       current->Tick();
 
       // VM & User tags.
       current = AppendTags(sample->vm_tag(), sample->user_tag(), current);
 
       ResetKind();
 
       // Truncated tag.
       if (sample->truncated()) {
         current = AppendTruncatedTag(current);
       }
 
       // Walk the sampled PCs.
       Code& code = Code::Handle();
-      for (intptr_t frame_index = sample->length() - 1;
-           frame_index >= 0;
+      for (intptr_t frame_index = sample->length() - 1; frame_index >= 0;
            frame_index--) {
         ASSERT(sample->At(frame_index) != 0);
         intptr_t index =
             GetProfileCodeIndex(sample->At(frame_index), sample->timestamp());
         ASSERT(index >= 0);
         ProfileCode* profile_code =
             GetProfileCode(sample->At(frame_index), sample->timestamp());
         ASSERT(profile_code->code_table_index() == index);
         code ^= profile_code->code();
         current = AppendKind(code, current);
         current = current->GetChild(index);
         current->Tick();
       }
 
       if (!sample->first_frame_executing()) {
         current = AppendExitFrame(sample->vm_tag(), current);
       }
     }
   }
 
   void BuildExclusiveCodeTrie(ProfileCodeTrieNode* root) {
     ScopeTimer sw("ProfileBuilder::BuildExclusiveCodeTrie",
                   FLAG_trace_profiler);
-    for (intptr_t sample_index = 0;
-         sample_index < samples_->length();
+    for (intptr_t sample_index = 0; sample_index < samples_->length();
          sample_index++) {
       ProcessedSample* sample = samples_->At(sample_index);
 
       // Tick the root.
       ProfileCodeTrieNode* current = root;
       current->Tick();
 
       // VM & User tags.
       current = AppendTags(sample->vm_tag(), sample->user_tag(), current);
 
       ResetKind();
 
       if (!sample->first_frame_executing()) {
         current = AppendExitFrame(sample->vm_tag(), current);
       }
 
       // Walk the sampled PCs.
       Code& code = Code::Handle();
-      for (intptr_t frame_index = 0;
-           frame_index < sample->length();
+      for (intptr_t frame_index = 0; frame_index < sample->length();
            frame_index++) {
         ASSERT(sample->At(frame_index) != 0);
         intptr_t index =
             GetProfileCodeIndex(sample->At(frame_index), sample->timestamp());
         ASSERT(index >= 0);
         ProfileCode* profile_code =
             GetProfileCode(sample->At(frame_index), sample->timestamp());
         ASSERT(profile_code->code_table_index() == index);
         code ^= profile_code->code();
         current = current->GetChild(index);
         if (ShouldTickNode(sample, frame_index)) {
           current->Tick();
         }
         current = AppendKind(code, current);
       }
       // Truncated tag.
       if (sample->truncated()) {
         current = AppendTruncatedTag(current);
       }
     }
   }
 
   void BuildFunctionTrie(Profile::TrieKind kind) {
-    ProfileFunctionTrieNode* root =
-        new ProfileFunctionTrieNode(
-            GetProfileFunctionTagIndex(VMTag::kRootTagId));
+    ProfileFunctionTrieNode* root = new ProfileFunctionTrieNode(
+        GetProfileFunctionTagIndex(VMTag::kRootTagId));
     // We tick the functions while building the trie, but, we don't want to do
     // it for both tries, just the exclusive trie.
     inclusive_tree_ = IsInclusiveTrie(kind);
     tick_functions_ = !inclusive_tree_;
     if (inclusive_tree_) {
       BuildInclusiveFunctionTrie(root);
     } else {
       BuildExclusiveFunctionTrie(root);
     }
     root->SortChildren();
     profile_->roots_[static_cast<intptr_t>(kind)] = root;
   }
 
   void BuildInclusiveFunctionTrie(ProfileFunctionTrieNode* root) {
     ScopeTimer sw("ProfileBuilder::BuildInclusiveFunctionTrie",
                   FLAG_trace_profiler);
     ASSERT(!tick_functions_);
-    for (intptr_t sample_index = 0;
-         sample_index < samples_->length();
+    for (intptr_t sample_index = 0; sample_index < samples_->length();
          sample_index++) {
       ProcessedSample* sample = samples_->At(sample_index);
 
       // Tick the root.
       ProfileFunctionTrieNode* current = root;
       current->Tick();
 
       // VM & User tags.
       current = AppendTags(sample->vm_tag(), sample->user_tag(), current);
 
       // Truncated tag.
       if (sample->truncated()) {
         current = AppendTruncatedTag(current);
       }
 
       // Walk the sampled PCs.
-      for (intptr_t frame_index = sample->length() - 1;
-           frame_index >= 0;
+      for (intptr_t frame_index = sample->length() - 1; frame_index >= 0;
            frame_index--) {
         ASSERT(sample->At(frame_index) != 0);
         current = ProcessFrame(current, sample_index, sample, frame_index);
       }
 
       if (!sample->first_frame_executing()) {
         current = AppendExitFrame(sample->vm_tag(), current);
       }
 
       sample->set_timeline_trie(current);
     }
   }
 
   void BuildExclusiveFunctionTrie(ProfileFunctionTrieNode* root) {
     ScopeTimer sw("ProfileBuilder::BuildExclusiveFunctionTrie",
                   FLAG_trace_profiler);
     ASSERT(tick_functions_);
-    for (intptr_t sample_index = 0;
-         sample_index < samples_->length();
+    for (intptr_t sample_index = 0; sample_index < samples_->length();
          sample_index++) {
       ProcessedSample* sample = samples_->At(sample_index);
 
       // Tick the root.
       ProfileFunctionTrieNode* current = root;
       current->Tick();
 
       // VM & User tags.
       current = AppendTags(sample->vm_tag(), sample->user_tag(), current);
 
       ResetKind();
 
       if (!sample->first_frame_executing()) {
         current = AppendExitFrame(sample->vm_tag(), current);
       }
 
       // Walk the sampled PCs.
-      for (intptr_t frame_index = 0;
-           frame_index < sample->length();
+      for (intptr_t frame_index = 0; frame_index < sample->length();
            frame_index++) {
         ASSERT(sample->At(frame_index) != 0);
         current = ProcessFrame(current, sample_index, sample, frame_index);
       }
 
       TickExitFrameFunction(sample->vm_tag(), sample_index);
 
       // Truncated tag.
       if (sample->truncated()) {
         current = AppendTruncatedTag(current);
         InclusiveTickTruncatedTag();
       }
     }
   }
 
-  ProfileFunctionTrieNode* ProcessFrame(
-      ProfileFunctionTrieNode* current,
-      intptr_t sample_index,
-      ProcessedSample* sample,
-      intptr_t frame_index) {
+  ProfileFunctionTrieNode* ProcessFrame(ProfileFunctionTrieNode* current,
+                                        intptr_t sample_index,
+                                        ProcessedSample* sample,
+                                        intptr_t frame_index) {
     const uword pc = sample->At(frame_index);
-    ProfileCode* profile_code = GetProfileCode(pc,
-                                               sample->timestamp());
+    ProfileCode* profile_code = GetProfileCode(pc, sample->timestamp());
     ProfileFunction* function = profile_code->function();
     ASSERT(function != NULL);
     const intptr_t code_index = profile_code->code_table_index();
     ASSERT(profile_code != NULL);
     const Code& code = Code::ZoneHandle(profile_code->code());
     GrowableArray<Function*>* inlined_functions = NULL;
     GrowableArray<TokenPosition>* inlined_token_positions = NULL;
     TokenPosition token_position = TokenPosition::kNoSource;
     if (!code.IsNull()) {
       inlined_functions_cache_.Get(pc, code, sample, frame_index,
-                                   &inlined_functions,
-                                   &inlined_token_positions,
+                                   &inlined_functions, &inlined_token_positions,
                                    &token_position);
       if (FLAG_trace_profiler_verbose) {
         for (intptr_t i = 0; i < inlined_functions->length(); i++) {
           const String& name =
               String::Handle((*inlined_functions)[i]->QualifiedScrubbedName());
-          THR_Print("InlinedFunction[%" Pd "] = {%s, %s}\n",
-                    i,
+          THR_Print("InlinedFunction[%" Pd "] = {%s, %s}\n", i,
                     name.ToCString(),
                     (*inlined_token_positions)[i].ToCString());
         }
       }
     }
-    if (code.IsNull() ||
-        (inlined_functions == NULL) ||
+    if (code.IsNull() || (inlined_functions == NULL) ||
         (inlined_functions->length() == 0)) {
       // No inlined functions.
       if (inclusive_tree_) {
         current = AppendKind(code, current);
       }
-      current = ProcessFunction(current,
-                                sample_index,
-                                sample,
-                                frame_index,
-                                function,
-                                token_position,
-                                code_index);
+      current = ProcessFunction(current, sample_index, sample, frame_index,
+                                function, token_position, code_index);
       if (!inclusive_tree_) {
         current = AppendKind(code, current);
       }
       return current;
     }
 
     ASSERT(code.is_optimized());
 
     if (inclusive_tree_) {
       for (intptr_t i = inlined_functions->length() - 1; i >= 0; i--) {
         Function* inlined_function = (*inlined_functions)[i];
         ASSERT(inlined_function != NULL);
         ASSERT(!inlined_function->IsNull());
         TokenPosition inlined_token_position = (*inlined_token_positions)[i];
         const bool inliner = i == (inlined_functions->length() - 1);
         if (inliner) {
           current = AppendKind(code, current);
         }
-        current = ProcessInlinedFunction(current,
-                                         sample_index,
-                                         sample,
-                                         frame_index,
-                                         inlined_function,
-                                         inlined_token_position,
-                                         code_index);
+        current = ProcessInlinedFunction(current, sample_index, sample,
+                                         frame_index, inlined_function,
+                                         inlined_token_position, code_index);
         if (inliner) {
           current = AppendKind(kInlineStart, current);
         }
       }
       current = AppendKind(kInlineFinish, current);
     } else {
       // Append the inlined children.
       current = AppendKind(kInlineFinish, current);
       for (intptr_t i = 0; i < inlined_functions->length(); i++) {
         Function* inlined_function = (*inlined_functions)[i];
         ASSERT(inlined_function != NULL);
         ASSERT(!inlined_function->IsNull());
         TokenPosition inlined_token_position = (*inlined_token_positions)[i];
         const bool inliner = i == (inlined_functions->length() - 1);
         if (inliner) {
           current = AppendKind(kInlineStart, current);
         }
-        current = ProcessInlinedFunction(current,
-                                         sample_index,
-                                         sample,
-                                         frame_index + i,
-                                         inlined_function,
-                                         inlined_token_position,
-                                         code_index);
+        current = ProcessInlinedFunction(current, sample_index, sample,
+                                         frame_index + i, inlined_function,
+                                         inlined_token_position, code_index);
         if (inliner) {
           current = AppendKind(code, current);
         }
       }
     }
 
     return current;
   }
 
   ProfileFunctionTrieNode* ProcessInlinedFunction(
       ProfileFunctionTrieNode* current,
       intptr_t sample_index,
       ProcessedSample* sample,
       intptr_t frame_index,
       Function* inlined_function,
       TokenPosition inlined_token_position,
       intptr_t code_index) {
     ProfileFunctionTable* function_table = profile_->functions_;
     ProfileFunction* function = function_table->LookupOrAdd(*inlined_function);
     ASSERT(function != NULL);
-    return ProcessFunction(current,
-                           sample_index,
-                           sample,
-                           frame_index,
-                           function,
-                           inlined_token_position,
-                           code_index);
+    return ProcessFunction(current, sample_index, sample, frame_index, function,
+                           inlined_token_position, code_index);
   }
 
   bool ShouldTickNode(ProcessedSample* sample, intptr_t frame_index) {
     if (frame_index != 0) {
       return true;
     }
     // Only tick the first frame's node, if we are executing OR
     // vm tags have been emitted.
-    return IsExecutingFrame(sample, frame_index) ||
-           !FLAG_profile_vm || vm_tags_emitted();
+    return IsExecutingFrame(sample, frame_index) || !FLAG_profile_vm ||
+           vm_tags_emitted();
   }
 
   ProfileFunctionTrieNode* ProcessFunction(ProfileFunctionTrieNode* current,
                                            intptr_t sample_index,
                                            ProcessedSample* sample,
                                            intptr_t frame_index,
                                            ProfileFunction* function,
                                            TokenPosition token_position,
                                            intptr_t code_index) {
     if (!function->is_visible()) {
       return current;
     }
     if (tick_functions_) {
       if (FLAG_trace_profiler_verbose) {
-        THR_Print("S[%" Pd "]F[%" Pd "] %s %s 0x%" Px "\n",
-                  sample_index,
-                  frame_index,
-                  function->Name(),
-                  token_position.ToCString(),
+        THR_Print("S[%" Pd "]F[%" Pd "] %s %s 0x%" Px "\n", sample_index,
+                  frame_index, function->Name(), token_position.ToCString(),
                   sample->At(frame_index));
       }
-      function->Tick(IsExecutingFrame(sample, frame_index),
-                     sample_index,
+      function->Tick(IsExecutingFrame(sample, frame_index), sample_index,
                      token_position);
     }
     function->AddProfileCode(code_index);
     current = current->GetChild(function->table_index());
     if (ShouldTickNode(sample, frame_index)) {
       current->Tick();
     }
     current->AddCodeObjectIndex(code_index);
     return current;
   }
@@ skipping 27 matching lines @@
 
   ProfileCodeTrieNode* AppendTruncatedTag(ProfileCodeTrieNode* current) {
     intptr_t truncated_tag_index =
         GetProfileCodeTagIndex(VMTag::kTruncatedTagId);
     ASSERT(truncated_tag_index >= 0);
     current = current->GetChild(truncated_tag_index);
     current->Tick();
     return current;
   }
 
-  ProfileCodeTrieNode* AppendVMTag(uword vm_tag,
-                                   ProfileCodeTrieNode* current) {
+  ProfileCodeTrieNode* AppendVMTag(uword vm_tag, ProfileCodeTrieNode* current) {
     if (VMTag::IsNativeEntryTag(vm_tag)) {
       // Insert a dummy kNativeTagId node.
       intptr_t tag_index = GetProfileCodeTagIndex(VMTag::kNativeTagId);
       current = current->GetChild(tag_index);
       // Give the tag a tick.
       current->Tick();
     } else if (VMTag::IsRuntimeEntryTag(vm_tag)) {
       // Insert a dummy kRuntimeTagId node.
       intptr_t tag_index = GetProfileCodeTagIndex(VMTag::kRuntimeTagId);
       current = current->GetChild(tag_index);
       // Give the tag a tick.
       current->Tick();
     } else {
       intptr_t tag_index = GetProfileCodeTagIndex(vm_tag);
       current = current->GetChild(tag_index);
       // Give the tag a tick.
       current->Tick();
     }
     return current;
   }
 
   ProfileCodeTrieNode* AppendSpecificNativeRuntimeEntryVMTag(
-      uword vm_tag, ProfileCodeTrieNode* current) {
+      uword vm_tag,
+      ProfileCodeTrieNode* current) {
     // Only Native and Runtime entries have a second VM tag.
-    if (!VMTag::IsNativeEntryTag(vm_tag) &&
-        !VMTag::IsRuntimeEntryTag(vm_tag)) {
+    if (!VMTag::IsNativeEntryTag(vm_tag) && !VMTag::IsRuntimeEntryTag(vm_tag)) {
       return current;
     }
     intptr_t tag_index = GetProfileCodeTagIndex(vm_tag);
     current = current->GetChild(tag_index);
     // Give the tag a tick.
     current->Tick();
     return current;
   }
 
   uword ProfileInfoKindToVMTag(ProfileInfoKind kind) {
@@ skipping 81 matching lines @@
   ProfileCodeTrieNode* AppendExitFrame(uword vm_tag,
                                        ProfileCodeTrieNode* current) {
     if (FLAG_profile_vm) {
       return current;
     }
 
     if (!VMTag::IsExitFrameTag(vm_tag)) {
       return current;
     }
 
-    if (VMTag::IsNativeEntryTag(vm_tag) ||
-        VMTag::IsRuntimeEntryTag(vm_tag)) {
+    if (VMTag::IsNativeEntryTag(vm_tag) || VMTag::IsRuntimeEntryTag(vm_tag)) {
       current = AppendSpecificNativeRuntimeEntryVMTag(vm_tag, current);
     } else {
       intptr_t tag_index = GetProfileCodeTagIndex(vm_tag);
       current = current->GetChild(tag_index);
       // Give the tag a tick.
       current->Tick();
     }
     return current;
   }
 
@@ skipping 27 matching lines @@
     }
 
     if (tag_order() == Profile::kNoTags) {
       return current;
     }
 
     return AppendUserTag(user_tag, current);
   }
 
   // ProfileFunctionTrieNode
-  void ResetKind() {
-    info_kind_ = kNone;
-  }
+  void ResetKind() { info_kind_ = kNone; }
 
   ProfileFunctionTrieNode* AppendKind(ProfileInfoKind kind,
                                       ProfileFunctionTrieNode* current) {
     if (!TagsEnabled(ProfilerService::kCodeTransitionTagsBit)) {
       // Only emit if debug tags are requested.
       return current;
     }
     if (kind != info_kind_) {
       info_kind_ = kind;
       intptr_t tag_index =
@@ skipping 53 matching lines @@
     } else {
       intptr_t tag_index = GetProfileFunctionTagIndex(vm_tag);
       current = current->GetChild(tag_index);
       // Give the tag a tick.
       current->Tick();
     }
     return current;
   }
 
   ProfileFunctionTrieNode* AppendSpecificNativeRuntimeEntryVMTag(
-      uword vm_tag, ProfileFunctionTrieNode* current) {
+      uword vm_tag,
+      ProfileFunctionTrieNode* current) {
     // Only Native and Runtime entries have a second VM tag.
-    if (!VMTag::IsNativeEntryTag(vm_tag) &&
-        !VMTag::IsRuntimeEntryTag(vm_tag)) {
+    if (!VMTag::IsNativeEntryTag(vm_tag) && !VMTag::IsRuntimeEntryTag(vm_tag)) {
       return current;
     }
     intptr_t tag_index = GetProfileFunctionTagIndex(vm_tag);
     current = current->GetChild(tag_index);
     // Give the tag a tick.
     current->Tick();
     return current;
   }
 
   ProfileFunctionTrieNode* AppendVMTags(uword vm_tag,
                                         ProfileFunctionTrieNode* current) {
     current = AppendVMTag(vm_tag, current);
     current = AppendSpecificNativeRuntimeEntryVMTag(vm_tag, current);
     return current;
   }
 
   ProfileFunctionTrieNode* AppendExitFrame(uword vm_tag,
                                            ProfileFunctionTrieNode* current) {
     if (FLAG_profile_vm) {
       return current;
     }
 
     if (!VMTag::IsExitFrameTag(vm_tag)) {
       return current;
     }
-    if (VMTag::IsNativeEntryTag(vm_tag) ||
-        VMTag::IsRuntimeEntryTag(vm_tag)) {
+    if (VMTag::IsNativeEntryTag(vm_tag) || VMTag::IsRuntimeEntryTag(vm_tag)) {
       current = AppendSpecificNativeRuntimeEntryVMTag(vm_tag, current);
     } else {
       intptr_t tag_index = GetProfileFunctionTagIndex(vm_tag);
       current = current->GetChild(tag_index);
       // Give the tag a tick.
       current->Tick();
     }
     return current;
   }
 
@@ skipping 88 matching lines @@
     if (tag == 0) {
       // No tag.
       return;
     }
     ProfileCodeTable* tag_table = profile_->tag_code_;
     intptr_t index = tag_table->FindCodeIndexForPC(tag);
     if (index >= 0) {
       // Already created.
       return;
     }
-    ProfileCode* code = new ProfileCode(ProfileCode::kTagCode,
-                                        tag,
-                                        tag + 1,
-                                        0,
-                                        null_code_);
+    ProfileCode* code =
+        new ProfileCode(ProfileCode::kTagCode, tag, tag + 1, 0, null_code_);
     index = tag_table->InsertCode(code);
     ASSERT(index >= 0);
   }
 
   ProfileCode* CreateProfileCodeReused(uword pc) {
-    ProfileCode* code = new ProfileCode(ProfileCode::kReusedCode,
-                                        pc,
-                                        pc + 1,
-                                        0,
-                                        null_code_);
+    ProfileCode* code =
+        new ProfileCode(ProfileCode::kReusedCode, pc, pc + 1, 0, null_code_);
     return code;
   }
 
   bool IsPCInDartHeap(uword pc) {
     return vm_isolate_->heap()->CodeContains(pc) ||
            thread_->isolate()->heap()->CodeContains(pc);
   }
 
 
   ProfileCode* FindOrRegisterNativeProfileCode(uword pc) {
     // Check if |pc| is already known in the live code table.
     ProfileCodeTable* live_table = profile_->live_code_;
     ProfileCode* profile_code = live_table->FindCodeForPC(pc);
     if (profile_code != NULL) {
       return profile_code;
     }
 
     // We haven't seen this pc yet.
     Code& code = Code::Handle(thread_->zone());
 
     // Check NativeSymbolResolver for pc.
     uintptr_t native_start = 0;
-    char* native_name = NativeSymbolResolver::LookupSymbolName(pc,
-                                                               &native_start);
+    char* native_name =
+        NativeSymbolResolver::LookupSymbolName(pc, &native_start);
     if (native_name == NULL) {
       // Failed to find a native symbol for pc.
       native_start = pc;
     }
 
 #if defined(HOST_ARCH_ARM)
     // The symbol for a Thumb function will be xxx1, but we may have samples
     // at function entry which will have pc xxx0.
     native_start &= ~1;
 #endif
 
     ASSERT(pc >= native_start);
-    profile_code = new ProfileCode(ProfileCode::kNativeCode,
-                                   native_start,
-                                   pc + 1,
-                                   0,
-                                   code);
+    profile_code = new ProfileCode(ProfileCode::kNativeCode, native_start,
+                                   pc + 1, 0, code);
     if (native_name != NULL) {
       profile_code->SetName(native_name);
       NativeSymbolResolver::FreeSymbolName(native_name);
     }
 
     RegisterLiveProfileCode(profile_code);
     return profile_code;
   }
 
   void RegisterLiveProfileCode(ProfileCode* code) {
@@ skipping 24 matching lines @@
       return code;
     }
     if ((code == NULL) && !IsPCInDartHeap(pc)) {
       // Not a PC from Dart code. Check with native code.
       return FindOrRegisterNativeProfileCode(pc);
     }
     // We either didn't find the code or it was compiled after the sample.
     return FindOrRegisterDeadProfileCode(pc);
   }
 
-  Profile::TagOrder tag_order() const {
-    return tag_order_;
-  }
+  Profile::TagOrder tag_order() const { return tag_order_; }
 
   bool vm_tags_emitted() const {
     return (tag_order_ == Profile::kUserVM) ||
-           (tag_order_ == Profile::kVMUser) ||
-           (tag_order_ == Profile::kVM);
+           (tag_order_ == Profile::kVMUser) || (tag_order_ == Profile::kVM);
   }
 
   bool TagsEnabled(intptr_t extra_tags_bits) const {
     return (extra_tags_ & extra_tags_bits) != 0;
   }
 
   Thread* thread_;
   Isolate* vm_isolate_;
   SampleFilter* filter_;
   Profile::TagOrder tag_order_;
@@ skipping 73 matching lines @@
   return tag_code_->At(index);
 }
 
 
 ProfileTrieNode* Profile::GetTrieRoot(TrieKind trie_kind) {
   return roots_[static_cast<intptr_t>(trie_kind)];
 }
 
 
 void Profile::PrintHeaderJSON(JSONObject* obj) {
-  obj->AddProperty("samplePeriod",
-                   static_cast<intptr_t>(FLAG_profile_period));
-  obj->AddProperty("stackDepth",
-                   static_cast<intptr_t>(FLAG_max_profile_depth));
+  obj->AddProperty("samplePeriod", static_cast<intptr_t>(FLAG_profile_period));
+  obj->AddProperty("stackDepth", static_cast<intptr_t>(FLAG_max_profile_depth));
   obj->AddProperty("sampleCount", sample_count());
   obj->AddProperty("timeSpan", MicrosecondsToSeconds(GetTimeSpan()));
   obj->AddPropertyTimeMicros("timeOriginMicros", min_time());
   obj->AddPropertyTimeMicros("timeExtentMicros", GetTimeSpan());
 
   ProfilerCounters counters = Profiler::counters();
   {
     JSONObject counts(obj, "counters");
-    counts.AddProperty64(
-        "bail_out_unknown_task",
-        counters.bail_out_unknown_task);
-    counts.AddProperty64(
-        "bail_out_jump_to_exception_handler",
-        counters.bail_out_jump_to_exception_handler);
-    counts.AddProperty64(
-        "bail_out_check_isolate",
-        counters.bail_out_check_isolate);
-    counts.AddProperty64(
-        "single_frame_sample_deoptimizing",
-        counters.single_frame_sample_deoptimizing);
-    counts.AddProperty64(
-        "single_frame_sample_register_check",
-        counters.single_frame_sample_register_check);
+    counts.AddProperty64("bail_out_unknown_task",
+                         counters.bail_out_unknown_task);
+    counts.AddProperty64("bail_out_jump_to_exception_handler",
+                         counters.bail_out_jump_to_exception_handler);
+    counts.AddProperty64("bail_out_check_isolate",
+                         counters.bail_out_check_isolate);
+    counts.AddProperty64("single_frame_sample_deoptimizing",
+                         counters.single_frame_sample_deoptimizing);
+    counts.AddProperty64("single_frame_sample_register_check",
+                         counters.single_frame_sample_register_check);
     counts.AddProperty64(
         "single_frame_sample_get_and_validate_stack_bounds",
         counters.single_frame_sample_get_and_validate_stack_bounds);
-    counts.AddProperty64(
-        "stack_walker_native",
-        counters.stack_walker_native);
-    counts.AddProperty64(
-        "stack_walker_dart_exit",
-        counters.stack_walker_dart_exit);
-    counts.AddProperty64(
-        "stack_walker_dart",
-        counters.stack_walker_dart);
-    counts.AddProperty64(
-        "stack_walker_none",
-        counters.stack_walker_none);
+    counts.AddProperty64("stack_walker_native", counters.stack_walker_native);
+    counts.AddProperty64("stack_walker_dart_exit",
+                         counters.stack_walker_dart_exit);
+    counts.AddProperty64("stack_walker_dart", counters.stack_walker_dart);
+    counts.AddProperty64("stack_walker_none", counters.stack_walker_none);
   }
 }
 
 
 void Profile::PrintTimelineFrameJSON(JSONObject* frames,
                                      ProfileTrieNode* current,
                                      ProfileTrieNode* parent,
                                      intptr_t* next_id) {
   ASSERT(current->frame_id() == -1);
   const intptr_t id = *next_id;
   *next_id = id + 1;
   current->set_frame_id(id);
   ASSERT(current->frame_id() != -1);
 
   {
     // The samples from many isolates may be merged into a single timeline,
     // so prefix frames id with the isolate.
     intptr_t isolate_id = reinterpret_cast<intptr_t>(isolate_);
-    const char* key = zone_->PrintToString("%" Pd "-%" Pd,
-                                           isolate_id, current->frame_id());
+    const char* key =
+        zone_->PrintToString("%" Pd "-%" Pd, isolate_id, current->frame_id());
     JSONObject frame(frames, key);
     frame.AddProperty("category", "Dart");
     ProfileFunction* func = GetFunction(current->table_index());
     frame.AddProperty("name", func->Name());
     if (parent != NULL) {
       ASSERT(parent->frame_id() != -1);
-      frame.AddPropertyF("parent", "%" Pd "-%" Pd,
-                         isolate_id, parent->frame_id());
+      frame.AddPropertyF("parent", "%" Pd "-%" Pd, isolate_id,
+                         parent->frame_id());
     }
   }
 
   for (intptr_t i = 0; i < current->NumChildren(); i++) {
     ProfileTrieNode* child = current->At(i);
     PrintTimelineFrameJSON(frames, child, current, next_id);
   }
 }
 
 
 void Profile::PrintTimelineJSON(JSONStream* stream) {
   ScopeTimer sw("Profile::PrintTimelineJSON", FLAG_trace_profiler);
   JSONObject obj(stream);
   obj.AddProperty("type", "_CpuProfileTimeline");
   PrintHeaderJSON(&obj);
   {
     JSONObject frames(&obj, "stackFrames");
     ProfileTrieNode* root = GetTrieRoot(kInclusiveFunction);
     intptr_t next_id = 0;
     PrintTimelineFrameJSON(&frames, root, NULL, &next_id);
   }
   {
     JSONArray events(&obj, "traceEvents");
     intptr_t pid = OS::ProcessId();
     intptr_t isolate_id = reinterpret_cast<intptr_t>(isolate_);
-    for (intptr_t sample_index = 0;
-         sample_index < samples_->length();
+    for (intptr_t sample_index = 0; sample_index < samples_->length();
          sample_index++) {
       ProcessedSample* sample = samples_->At(sample_index);
       JSONObject event(&events);
       event.AddProperty("ph", "P");  // kind = sample event
       event.AddProperty64("pid", pid);
       event.AddProperty64("tid", OSThread::ThreadIdToIntPtr(sample->tid()));
       event.AddPropertyTimeMicros("ts", sample->timestamp());
       event.AddProperty("cat", "Dart");
 
       ProfileTrieNode* trie = sample->timeline_trie();
       ASSERT(trie->frame_id() != -1);
-      event.AddPropertyF("sf", "%" Pd "-%" Pd,
-                         isolate_id, trie->frame_id());
+      event.AddPropertyF("sf", "%" Pd "-%" Pd, isolate_id, trie->frame_id());
     }
   }
 }
 
 
 ProfileFunction* Profile::FindFunction(const Function& function) {
   return (functions_ != NULL) ? functions_->Lookup(function) : NULL;
 }
 
 
@@ skipping 230 matching lines @@
 
 class NoAllocationSampleFilter : public SampleFilter {
  public:
   NoAllocationSampleFilter(Isolate* isolate,
                            intptr_t thread_task_mask,
                            int64_t time_origin_micros,
                            int64_t time_extent_micros)
       : SampleFilter(isolate,
                      thread_task_mask,
                      time_origin_micros,
-                     time_extent_micros) {
-  }
+                     time_extent_micros) {}
 
-  bool FilterSample(Sample* sample) {
-    return !sample->is_allocation_sample();
-  }
+  bool FilterSample(Sample* sample) { return !sample->is_allocation_sample(); }
 };
 
 
 void ProfilerService::PrintJSON(JSONStream* stream,
                                 Profile::TagOrder tag_order,
                                 intptr_t extra_tags,
                                 int64_t time_origin_micros,
                                 int64_t time_extent_micros) {
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
-  NoAllocationSampleFilter filter(isolate,
-                                  Thread::kMutatorTask,
-                                  time_origin_micros,
-                                  time_extent_micros);
+  NoAllocationSampleFilter filter(isolate, Thread::kMutatorTask,
+                                  time_origin_micros, time_extent_micros);
   const bool as_timeline = false;
   PrintJSONImpl(thread, stream, tag_order, extra_tags, &filter, as_timeline);
 }
 
 
 class ClassAllocationSampleFilter : public SampleFilter {
  public:
   ClassAllocationSampleFilter(Isolate* isolate,
                               const Class& cls,
                               intptr_t thread_task_mask,
@@ skipping 17 matching lines @@
 };
 
 
 void ProfilerService::PrintAllocationJSON(JSONStream* stream,
                                           Profile::TagOrder tag_order,
                                           const Class& cls,
                                           int64_t time_origin_micros,
                                           int64_t time_extent_micros) {
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
-  ClassAllocationSampleFilter filter(isolate,
-                                     cls,
-                                     Thread::kMutatorTask,
-                                     time_origin_micros,
-                                     time_extent_micros);
+  ClassAllocationSampleFilter filter(isolate, cls, Thread::kMutatorTask,
+                                     time_origin_micros, time_extent_micros);
   const bool as_timeline = false;
   PrintJSONImpl(thread, stream, tag_order, kNoExtraTags, &filter, as_timeline);
 }
 
 
 void ProfilerService::PrintTimelineJSON(JSONStream* stream,
                                         Profile::TagOrder tag_order,
                                         int64_t time_origin_micros,
                                         int64_t time_extent_micros) {
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   const intptr_t thread_task_mask = Thread::kMutatorTask |
                                     Thread::kCompilerTask |
-                                    Thread::kSweeperTask |
-                                    Thread::kMarkerTask;
-  NoAllocationSampleFilter filter(isolate,
-                                  thread_task_mask,
-                                  time_origin_micros,
+                                    Thread::kSweeperTask | Thread::kMarkerTask;
+  NoAllocationSampleFilter filter(isolate, thread_task_mask, time_origin_micros,
                                   time_extent_micros);
   const bool as_timeline = true;
   PrintJSONImpl(thread, stream, tag_order, kNoExtraTags, &filter, as_timeline);
 }
 
 
 void ProfilerService::ClearSamples() {
   SampleBuffer* sample_buffer = Profiler::sample_buffer();
   if (sample_buffer == NULL) {
     return;
   }
 
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
 
   // Disable thread interrupts while processing the buffer.
   DisableThreadInterruptsScope dtis(thread);
 
   ClearProfileVisitor clear_profile(isolate);
   sample_buffer->VisitSamples(&clear_profile);
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart