clang-format runtime/vm

runtime/vm/assembler.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/assembler.h"
 
 #include "platform/utils.h"
 #include "vm/cpu.h"
 #include "vm/heap.h"
 #include "vm/memory_region.h"
 #include "vm/os.h"
 #include "vm/zone.h"
 
 namespace dart {
 
-DEFINE_FLAG(bool, check_code_pointer, false,
+DEFINE_FLAG(bool,
+            check_code_pointer,
+            false,
             "Verify instructions offset in code object."
             "NOTE: This breaks the profiler.");
-DEFINE_FLAG(bool, code_comments, false,
+DEFINE_FLAG(bool,
+            code_comments,
+            false,
             "Include comments into code and disassembly");
 #if defined(TARGET_ARCH_ARM) || defined(TARGET_ARCH_MIPS)
-DEFINE_FLAG(bool, use_far_branches, false,
+DEFINE_FLAG(bool,
+            use_far_branches,
+            false,
             "Enable far branches for ARM and MIPS");
 #endif
 
 static uword NewContents(intptr_t capacity) {
   Zone* zone = Thread::Current()->zone();
   uword result = zone->AllocUnsafe(capacity);
 #if defined(DEBUG)
   // Initialize the buffer with kBreakPointInstruction to force a break
   // point if we ever execute an uninitialized part of the code buffer.
   Assembler::InitializeMemoryWithBreakpoints(result, capacity);
@@ skipping 42 matching lines @@
   has_ensured_capacity_ = false;
   fixups_processed_ = false;
 #endif
 
   // Verify internal state.
   ASSERT(Capacity() == kInitialBufferCapacity);
   ASSERT(Size() == 0);
 }
 
 
-AssemblerBuffer::~AssemblerBuffer() {
-}
+AssemblerBuffer::~AssemblerBuffer() {}
 
 
 void AssemblerBuffer::ProcessFixups(const MemoryRegion& region) {
   AssemblerFixup* fixup = fixup_;
   while (fixup != NULL) {
     fixup->Process(region, fixup->position());
     fixup = fixup->previous();
   }
 }
 
@@ skipping 16 matching lines @@
   intptr_t old_capacity = Capacity();
   intptr_t new_capacity =
       Utils::Minimum(old_capacity * 2, old_capacity + 1 * MB);
   if (new_capacity < old_capacity) {
     FATAL("Unexpected overflow in AssemblerBuffer::ExtendCapacity");
   }
 
   // Allocate the new data area and copy contents of the old one to it.
   uword new_contents = NewContents(new_capacity);
   memmove(reinterpret_cast<void*>(new_contents),
-          reinterpret_cast<void*>(contents_),
-          old_size);
+          reinterpret_cast<void*>(contents_), old_size);
 
   // Compute the relocation delta and switch to the new contents area.
   intptr_t delta = new_contents - contents_;
   contents_ = new_contents;
 
   // Update the cursor and recompute the limit.
   cursor_ += delta;
   limit_ = ComputeLimit(new_contents, new_capacity);
 
   // Verify internal state.
   ASSERT(Capacity() == new_capacity);
   ASSERT(Size() == old_size);
 }
 
 
 class PatchCodeWithHandle : public AssemblerFixup {
  public:
   PatchCodeWithHandle(ZoneGrowableArray<intptr_t>* pointer_offsets,
                       const Object& object)
-      : pointer_offsets_(pointer_offsets), object_(object) {
-  }
+      : pointer_offsets_(pointer_offsets), object_(object) {}
 
   void Process(const MemoryRegion& region, intptr_t position) {
     // Patch the handle into the code. Once the instructions are installed into
     // a raw code object and the pointer offsets are setup, the handle is
     // resolved.
     region.Store<const Object*>(position, &object_);
     pointer_offsets_->Add(position);
   }
 
   virtual bool IsPointerOffset() const { return true; }
@@ skipping 55 matching lines @@
 
 void Assembler::Comment(const char* format, ...) {
   if (EmittingComments()) {
     char buffer[1024];
 
     va_list args;
     va_start(args, format);
     OS::VSNPrint(buffer, sizeof(buffer), format, args);
     va_end(args);
 
-    comments_.Add(new CodeComment(buffer_.GetPosition(),
-                                  String::ZoneHandle(String::New(buffer,
-                                                                 Heap::kOld))));
+    comments_.Add(
+        new CodeComment(buffer_.GetPosition(),
+                        String::ZoneHandle(String::New(buffer, Heap::kOld))));
   }
 }
 
 
 bool Assembler::EmittingComments() {
   return FLAG_code_comments || FLAG_disassemble || FLAG_disassemble_optimized;
 }
 
 
 const Code::Comments& Assembler::GetCodeComments() const {
@@ skipping 63 matching lines @@
 
 
 intptr_t ObjectPoolWrapper::FindImmediate(uword imm) {
   return FindObject(ObjectPoolWrapperEntry(imm, ObjectPool::kImmediate),
                     kNotPatchable);
 }
 
 
 intptr_t ObjectPoolWrapper::FindNativeEntry(const ExternalLabel* label,
                                             Patchability patchable) {
-  return FindObject(ObjectPoolWrapperEntry(label->address(),
-                                           ObjectPool::kNativeEntry),
-                    patchable);
+  return FindObject(
+      ObjectPoolWrapperEntry(label->address(), ObjectPool::kNativeEntry),
+      patchable);
 }
 
 
 RawObjectPool* ObjectPoolWrapper::MakeObjectPool() {
   intptr_t len = object_pool_.length();
   if (len == 0) {
     return Object::empty_object_pool().raw();
   }
   const ObjectPool& result = ObjectPool::Handle(ObjectPool::New(len));
   const TypedData& info_array = TypedData::Handle(result.info_array());
   for (intptr_t i = 0; i < len; ++i) {
     ObjectPool::EntryType info = object_pool_[i].type_;
     info_array.SetInt8(i, static_cast<int8_t>(info));
     if (info == ObjectPool::kTaggedObject) {
       result.SetObjectAt(i, *object_pool_[i].obj_);
     } else {
       result.SetRawValueAt(i, object_pool_[i].raw_value_);
     }
   }
   return result.raw();
 }
 
 
 }  // namespace dart