clang-format runtime/vm

runtime/vm/class_table.cc

 // Copyright (c) 2012, 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/class_table.h"
 
 #include "vm/atomic.h"
 #include "vm/flags.h"
 #include "vm/freelist.h"
 #include "vm/growable_array.h"
 #include "vm/heap.h"
 #include "vm/object.h"
 #include "vm/raw_object.h"
 #include "vm/visitor.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, print_class_table, false, "Print initial class table.");
 
 ClassTable::ClassTable()
-    : top_(kNumPredefinedCids), capacity_(0), table_(NULL),
+    : top_(kNumPredefinedCids),
+      capacity_(0),
+      table_(NULL),
       old_tables_(new MallocGrowableArray<RawClass**>()) {
   NOT_IN_PRODUCT(class_heap_stats_table_ = NULL);
   NOT_IN_PRODUCT(predefined_class_heap_stats_table_ = NULL);
   if (Dart::vm_isolate() == NULL) {
     capacity_ = initial_capacity_;
     table_ = reinterpret_cast<RawClass**>(
         calloc(capacity_, sizeof(RawClass*)));  // NOLINT
   } else {
     // Duplicate the class table from the VM isolate.
     ClassTable* vm_class_table = Dart::vm_isolate()->class_table();
@@ skipping 11 matching lines @@
 #ifndef PRODUCT
     class_heap_stats_table_ = reinterpret_cast<ClassHeapStats*>(
         calloc(capacity_, sizeof(ClassHeapStats)));  // NOLINT
     for (intptr_t i = 0; i < capacity_; i++) {
       class_heap_stats_table_[i].Initialize();
     }
 #endif  // !PRODUCT
   }
 #ifndef PRODUCT
   predefined_class_heap_stats_table_ = reinterpret_cast<ClassHeapStats*>(
-        calloc(kNumPredefinedCids, sizeof(ClassHeapStats)));  // NOLINT
+      calloc(kNumPredefinedCids, sizeof(ClassHeapStats)));  // NOLINT
   for (intptr_t i = 0; i < kNumPredefinedCids; i++) {
     predefined_class_heap_stats_table_[i].Initialize();
   }
 #endif  // !PRODUCT
 }
 
 
 ClassTable::ClassTable(ClassTable* original)
     : top_(original->top_),
       capacity_(original->top_),
@@ skipping 51 matching lines @@
   intptr_t index = cls.id();
   if (index != kIllegalCid) {
     ASSERT(index > 0);
     ASSERT(index < kNumPredefinedCids);
     ASSERT(table_[index] == 0);
     ASSERT(index < capacity_);
     table_[index] = cls.raw();
     // Add the vtable for this predefined class into the static vtable registry
     // if it has not been setup yet.
     cpp_vtable cls_vtable = cls.handle_vtable();
-    AtomicOperations::CompareAndSwapWord(
-        &(Object::builtin_vtables_[index]), 0, cls_vtable);
+    AtomicOperations::CompareAndSwapWord(&(Object::builtin_vtables_[index]), 0,
+                                         cls_vtable);
     ASSERT(Object::builtin_vtables_[index] == cls_vtable);
   } else {
     if (top_ == capacity_) {
       // Grow the capacity of the class table.
       // TODO(koda): Add ClassTable::Grow to share code.
       intptr_t new_capacity = capacity_ + capacity_increment_;
       RawClass** new_table = reinterpret_cast<RawClass**>(
           malloc(new_capacity * sizeof(RawClass*)));  // NOLINT
       memmove(new_table, table_, capacity_ * sizeof(RawClass*));
 #ifndef PRODUCT
@@ skipping 292 matching lines @@
   ASSERT(cid > 0);
   if (cid < kNumPredefinedCids) {
     return &predefined_class_heap_stats_table_[cid];
   }
   ASSERT(cid < top_);
   return &class_heap_stats_table_[cid];
 }
 
 
 ClassHeapStats* ClassTable::StatsWithUpdatedSize(intptr_t cid) {
-  if (!HasValidClassAt(cid) ||
-      (cid == kFreeListElement) ||
-      (cid == kForwardingCorpse) ||
-      (cid == kSmiCid)) {
+  if (!HasValidClassAt(cid) || (cid == kFreeListElement) ||
+      (cid == kForwardingCorpse) || (cid == kSmiCid)) {
     return NULL;
   }
   Class& cls = Class::Handle(At(cid));
   if (!(cls.is_finalized() || cls.is_prefinalized())) {
     // Not finalized.
     return NULL;
   }
   ClassHeapStats* stats = PreliminaryStatsAt(cid);
   if (ShouldUpdateSizeForClassId(cid)) {
     stats->UpdateSize(cls.instance_size());
@@ skipping 27 matching lines @@
   for (intptr_t i = 0; i < kNumPredefinedCids; i++) {
     predefined_class_heap_stats_table_[i].UpdatePromotedAfterNewGC();
   }
   for (intptr_t i = kNumPredefinedCids; i < top_; i++) {
     class_heap_stats_table_[i].UpdatePromotedAfterNewGC();
   }
 }
 
 
 ClassHeapStats** ClassTable::TableAddressFor(intptr_t cid) {
-  return (cid < kNumPredefinedCids)
-      ? &predefined_class_heap_stats_table_
-      : &class_heap_stats_table_;
+  return (cid < kNumPredefinedCids) ? &predefined_class_heap_stats_table_
+                                    : &class_heap_stats_table_;
 }
 
 
 intptr_t ClassTable::TableOffsetFor(intptr_t cid) {
   return (cid < kNumPredefinedCids)
-      ? OFFSET_OF(ClassTable, predefined_class_heap_stats_table_)
-      : OFFSET_OF(ClassTable, class_heap_stats_table_);
+             ? OFFSET_OF(ClassTable, predefined_class_heap_stats_table_)
+             : OFFSET_OF(ClassTable, class_heap_stats_table_);
 }
 
 
 intptr_t ClassTable::ClassOffsetFor(intptr_t cid) {
   return cid * sizeof(ClassHeapStats);  // NOLINT
 }
 
 
 intptr_t ClassTable::CounterOffsetFor(intptr_t cid, bool is_new_space) {
   const intptr_t class_offset = ClassOffsetFor(cid);
-  const intptr_t count_field_offset = is_new_space
-      ? ClassHeapStats::allocated_since_gc_new_space_offset()
-      : ClassHeapStats::allocated_since_gc_old_space_offset();
+  const intptr_t count_field_offset =
+      is_new_space ? ClassHeapStats::allocated_since_gc_new_space_offset()
+                   : ClassHeapStats::allocated_since_gc_old_space_offset();
   return class_offset + count_field_offset;
 }
 
 
 intptr_t ClassTable::StateOffsetFor(intptr_t cid) {
   return ClassOffsetFor(cid) + ClassHeapStats::state_offset();
 }
 
 
 intptr_t ClassTable::SizeOffsetFor(intptr_t cid, bool is_new_space) {
   const uword class_offset = ClassOffsetFor(cid);
-  const uword size_field_offset = is_new_space
-      ? ClassHeapStats::allocated_size_since_gc_new_space_offset()
-      : ClassHeapStats::allocated_size_since_gc_old_space_offset();
+  const uword size_field_offset =
+      is_new_space ? ClassHeapStats::allocated_size_since_gc_new_space_offset()
+                   : ClassHeapStats::allocated_size_since_gc_old_space_offset();
   return class_offset + size_field_offset;
 }
 
 
 void ClassTable::AllocationProfilePrintJSON(JSONStream* stream) {
   if (!FLAG_support_service) {
     return;
   }
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   Heap* heap = isolate->heap();
   ASSERT(heap != NULL);
   JSONObject obj(stream);
   obj.AddProperty("type", "AllocationProfile");
   if (isolate->last_allocationprofile_accumulator_reset_timestamp() != 0) {
     obj.AddPropertyF(
-        "dateLastAccumulatorReset",
-        "%" Pd64 "",
+        "dateLastAccumulatorReset", "%" Pd64 "",
         isolate->last_allocationprofile_accumulator_reset_timestamp());
   }
   if (isolate->last_allocationprofile_gc_timestamp() != 0) {
-    obj.AddPropertyF(
-        "dateLastServiceGC",
-        "%" Pd64 "",
-        isolate->last_allocationprofile_gc_timestamp());
+    obj.AddPropertyF("dateLastServiceGC", "%" Pd64 "",
+                     isolate->last_allocationprofile_gc_timestamp());
   }
 
   {
     JSONObject heaps(&obj, "heaps");
-    {
-      heap->PrintToJSONObject(Heap::kNew, &heaps);
-    }
-    {
-      heap->PrintToJSONObject(Heap::kOld, &heaps);
-    }
+    { heap->PrintToJSONObject(Heap::kNew, &heaps); }
+    { heap->PrintToJSONObject(Heap::kOld, &heaps); }
   }
   {
     JSONArray arr(&obj, "members");
     Class& cls = Class::Handle();
     for (intptr_t i = 1; i < top_; i++) {
       const ClassHeapStats* stats = StatsWithUpdatedSize(i);
       if (stats != NULL) {
         JSONObject obj(&arr);
         cls = At(i);
         stats->PrintToJSONObject(cls, &obj);
@@ skipping 25 matching lines @@
 void ClassTable::UpdateLiveNew(intptr_t cid, intptr_t size) {
   ClassHeapStats* stats = PreliminaryStatsAt(cid);
   ASSERT(stats != NULL);
   ASSERT(size >= 0);
   stats->post_gc.AddNew(size);
 }
 #endif  // !PRODUCT
 
 
 }  // namespace dart