clang-format runtime/vm

runtime/vm/deopt_instructions.h

 // 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.
 
 #ifndef RUNTIME_VM_DEOPT_INSTRUCTIONS_H_
 #define RUNTIME_VM_DEOPT_INSTRUCTIONS_H_
 
 #include "vm/allocation.h"
 #include "vm/assembler.h"
 #include "vm/code_generator.h"
@@ skipping 11 matching lines @@
 class Value;
 class MaterializeObjectInstr;
 class StackFrame;
 class TimelineEvent;
 
 // Holds all data relevant for execution of deoptimization instructions.
 // Structure is allocated in C-heap.
 class DeoptContext {
  public:
   enum DestFrameOptions {
-    kDestIsOriginalFrame,   // Replace the original frame with deopt frame.
-    kDestIsAllocated        // Write deopt frame to a buffer.
+    kDestIsOriginalFrame,  // Replace the original frame with deopt frame.
+    kDestIsAllocated       // Write deopt frame to a buffer.
   };
 
   // If 'deoptimizing_code' is false, only frame is being deoptimized.
   DeoptContext(const StackFrame* frame,
                const Code& code,
                DestFrameOptions dest_options,
                fpu_register_t* fpu_registers,
                intptr_t* cpu_registers,
                bool is_lazy_deopt,
                bool deoptimizing_code);
@@ skipping 65 matching lines @@
   // Base pointer points to the slot with the lowest address in the frame
   // including incoming arguments and artificial deoptimization frame
   // on top of it.
   // Note: artificial frame created by the deoptimization stub is considered
   // part of the frame because it contains saved caller PC and FP that
   // deoptimization will fill in.
   intptr_t* FrameBase(const StackFrame* frame) {
 #if !defined(TARGET_ARCH_DBC)
     // SP of the deoptimization frame is the lowest slot because
     // stack is growing downwards.
-    return reinterpret_cast<intptr_t*>(
-      frame->sp() - (kDartFrameFixedSize * kWordSize));
+    return reinterpret_cast<intptr_t*>(frame->sp() -
+                                       (kDartFrameFixedSize * kWordSize));
 #else
     // First argument is the lowest slot because stack is growing upwards.
     return reinterpret_cast<intptr_t*>(
         frame->fp() - (kDartFrameFixedSize + num_args_) * kWordSize);
 #endif  // !defined(TARGET_ARCH_DBC)
   }
 
   void set_dest_frame(const StackFrame* frame) {
     ASSERT(frame != NULL && dest_frame_ == NULL);
     dest_frame_ = FrameBase(frame);
@@ skipping 25 matching lines @@
   // Materializes all deferred objects.  Returns the total number of
   // artificial arguments used during deoptimization.
   intptr_t MaterializeDeferredObjects();
 
   RawArray* DestFrameAsArray();
 
   void VisitObjectPointers(ObjectPointerVisitor* visitor);
 
   void DeferMaterializedObjectRef(intptr_t idx, intptr_t* slot) {
     deferred_slots_ = new DeferredObjectRef(
-        idx,
-        reinterpret_cast<RawObject**>(slot),
-        deferred_slots_);
+        idx, reinterpret_cast<RawObject**>(slot), deferred_slots_);
   }
 
   void DeferMaterialization(double value, RawDouble** slot) {
     deferred_slots_ = new DeferredDouble(
-        value,
-        reinterpret_cast<RawObject**>(slot),
-        deferred_slots_);
+        value, reinterpret_cast<RawObject**>(slot), deferred_slots_);
   }
 
   void DeferMintMaterialization(int64_t value, RawMint** slot) {
     deferred_slots_ = new DeferredMint(
-        value,
-        reinterpret_cast<RawObject**>(slot),
-        deferred_slots_);
+        value, reinterpret_cast<RawObject**>(slot), deferred_slots_);
   }
 
   void DeferMaterialization(simd128_value_t value, RawFloat32x4** slot) {
     deferred_slots_ = new DeferredFloat32x4(
-        value,
-        reinterpret_cast<RawObject**>(slot),
-        deferred_slots_);
+        value, reinterpret_cast<RawObject**>(slot), deferred_slots_);
   }
 
   void DeferMaterialization(simd128_value_t value, RawFloat64x2** slot) {
     deferred_slots_ = new DeferredFloat64x2(
-        value,
-        reinterpret_cast<RawObject**>(slot),
-        deferred_slots_);
+        value, reinterpret_cast<RawObject**>(slot), deferred_slots_);
   }
 
   void DeferMaterialization(simd128_value_t value, RawInt32x4** slot) {
     deferred_slots_ = new DeferredInt32x4(
-        value,
-        reinterpret_cast<RawObject**>(slot),
-        deferred_slots_);
+        value, reinterpret_cast<RawObject**>(slot), deferred_slots_);
   }
 
   void DeferRetAddrMaterialization(intptr_t index,
                                    intptr_t deopt_id,
                                    intptr_t* slot) {
     deferred_slots_ = new DeferredRetAddr(
-        index,
-        deopt_id,
-        reinterpret_cast<RawObject**>(slot),
-        deferred_slots_);
+        index, deopt_id, reinterpret_cast<RawObject**>(slot), deferred_slots_);
   }
 
   void DeferPcMarkerMaterialization(intptr_t index, intptr_t* slot) {
     deferred_slots_ = new DeferredPcMarker(
-        index,
-        reinterpret_cast<RawObject**>(slot),
-        deferred_slots_);
+        index, reinterpret_cast<RawObject**>(slot), deferred_slots_);
   }
 
   void DeferPpMaterialization(intptr_t index, RawObject** slot) {
     deferred_slots_ = new DeferredPp(index, slot, deferred_slots_);
   }
 
   DeferredObject* GetDeferredObject(intptr_t idx) const {
     return deferred_objects_[idx];
   }
 
@@ skipping 19 matching lines @@
     }
   }
 
   // Sets the materialized value for some deferred object.
   //
   // Claims ownership of the memory for 'object'.
   void SetDeferredObjectAt(intptr_t idx, DeferredObject* object) {
     deferred_objects_[idx] = object;
   }
 
-  intptr_t DeferredObjectsCount() const {
-    return deferred_objects_count_;
-  }
+  intptr_t DeferredObjectsCount() const { return deferred_objects_count_; }
 
   RawCode* code_;
   RawObjectPool* object_pool_;
   RawTypedData* deopt_info_;
   bool dest_frame_is_allocated_;
   intptr_t* dest_frame_;
   intptr_t dest_frame_size_;
   bool source_frame_is_allocated_;
   intptr_t* source_frame_;
   intptr_t source_frame_size_;
@@ skipping 11 matching lines @@
   intptr_t deferred_objects_count_;
   DeferredObject** deferred_objects_;
 
   const bool is_lazy_deopt_;
   const bool deoptimizing_code_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptContext);
 };
 
 
-
 // Represents one deopt instruction, e.g, setup return address, store object,
 // store register, etc. The target is defined by instruction's position in
 // the deopt-info array.
 class DeoptInstr : public ZoneAllocated {
  public:
   enum Kind {
     kRetAddress,
     kConstant,
     kWord,
     kDouble,
@@ skipping 51 matching lines @@
   static intptr_t GetFieldCount(DeoptInstr* instr) {
     ASSERT(instr->kind() == DeoptInstr::kMaterializeObject);
     return instr->source_index();
   }
 
  protected:
   friend class DeoptInfoBuilder;
 
   virtual intptr_t source_index() const = 0;
 
-  virtual const char* ArgumentsToCString() const {
-    return NULL;
-  }
+  virtual const char* ArgumentsToCString() const { return NULL; }
 
  private:
   static const char* KindToCString(Kind kind);
 
   DISALLOW_COPY_AND_ASSIGN(DeoptInstr);
 };
 
 
 // Helper class that allows to read a value of the given register from
 // the DeoptContext as the specified type.
 // It calls different method depending on which kind of register (cpu/fpu) and
 // destination types are specified.
-template<typename RegisterType, typename DestinationType>
+template <typename RegisterType, typename DestinationType>
 struct RegisterReader;
 
-template<typename T>
+template <typename T>
 struct RegisterReader<Register, T> {
   static intptr_t Read(DeoptContext* context, Register reg) {
     return context->RegisterValue(reg);
   }
 };
 
-template<>
+template <>
 struct RegisterReader<FpuRegister, double> {
   static double Read(DeoptContext* context, FpuRegister reg) {
     return context->FpuRegisterValue(reg);
   }
 };
 
 
-template<>
+template <>
 struct RegisterReader<FpuRegister, simd128_value_t> {
   static simd128_value_t Read(DeoptContext* context, FpuRegister reg) {
     return context->FpuRegisterValueAsSimd128(reg);
   }
 };
 
 
 // Class that encapsulates reading and writing of values that were either in
 // the registers in the optimized code or were spilled from those registers
 // to the stack.
-template<typename RegisterType>
+template <typename RegisterType>
 class RegisterSource {
  public:
   enum Kind {
     // Spilled register source represented as its spill slot.
     kStackSlot = 0,
     // Register source represented as its register index.
     kRegister = 1
   };
 
   explicit RegisterSource(intptr_t source_index)
-      : source_index_(source_index) { }
+      : source_index_(source_index) {}
 
   RegisterSource(Kind kind, intptr_t index)
-      : source_index_(KindField::encode(kind) | RawIndexField::encode(index)) {
-  }
+      : source_index_(KindField::encode(kind) | RawIndexField::encode(index)) {}
 
-  template<typename T>
+  template <typename T>
   T Value(DeoptContext* context) const {
     if (is_register()) {
-      return static_cast<T>(RegisterReader<RegisterType, T>::Read(
-        context, reg()));
+      return static_cast<T>(
+          RegisterReader<RegisterType, T>::Read(context, reg()));
     } else {
-      return *reinterpret_cast<T*>(context->GetSourceFrameAddressAt(
-          raw_index()));
+      return *reinterpret_cast<T*>(
+          context->GetSourceFrameAddressAt(raw_index()));
     }
   }
 
   intptr_t source_index() const { return source_index_; }
 
   const char* ToCString() const {
     if (is_register()) {
       return Name(reg());
     } else {
-      return Thread::Current()->zone()->PrintToString(
-          "s%" Pd "", raw_index());
+      return Thread::Current()->zone()->PrintToString("s%" Pd "", raw_index());
     }
   }
 
  private:
-  class KindField : public BitField<intptr_t, intptr_t, 0, 1> { };
-  class RawIndexField :
-      public BitField<intptr_t, intptr_t, 1, kBitsPerWord - 1> { };
+  class KindField : public BitField<intptr_t, intptr_t, 0, 1> {};
+  class RawIndexField
+      : public BitField<intptr_t, intptr_t, 1, kBitsPerWord - 1> {};
 
   bool is_register() const {
     return KindField::decode(source_index_) == kRegister;
   }
   intptr_t raw_index() const { return RawIndexField::decode(source_index_); }
 
   RegisterType reg() const { return static_cast<RegisterType>(raw_index()); }
 
-  static const char* Name(Register reg) {
-    return Assembler::RegisterName(reg);
-  }
+  static const char* Name(Register reg) { return Assembler::RegisterName(reg); }
 
   static const char* Name(FpuRegister fpu_reg) {
     return Assembler::FpuRegisterName(fpu_reg);
   }
 
   const intptr_t source_index_;
 };
 
 
 typedef RegisterSource<Register> CpuRegisterSource;
@@ skipping 44 matching lines @@
     ASSERT(frame_start_ == -1);
     frame_start_ = instructions_.length();
   }
 
  private:
   friend class CompilerDeoptInfo;  // For current_info_number_.
 
   class TrieNode;
 
   CpuRegisterSource ToCpuRegisterSource(const Location& loc);
-  FpuRegisterSource ToFpuRegisterSource(const Location& loc,
-                                      Location::Kind expected_stack_slot_kind);
+  FpuRegisterSource ToFpuRegisterSource(
+      const Location& loc,
+      Location::Kind expected_stack_slot_kind);
 
   intptr_t FindOrAddObjectInTable(const Object& obj) const;
   intptr_t FindMaterialization(MaterializeObjectInstr* mat) const;
   intptr_t CalculateStackIndex(const Location& source_loc) const;
 
   intptr_t FrameSize() const {
     ASSERT(frame_start_ != -1);
     const intptr_t frame_size = instructions_.length() - frame_start_;
     ASSERT(frame_size >= 0);
     return frame_size;
@@ skipping 44 matching lines @@
   // Set the output parameters (offset, info, reason) to the entry values at
   // the index into the table (not an array index).
   static void GetEntry(const Array& table,
                        intptr_t index,
                        Smi* offset,
                        TypedData* info,
                        Smi* reason_and_flags);
 
   static RawSmi* EncodeReasonAndFlags(ICData::DeoptReasonId reason,
                                       uint32_t flags) {
-    return Smi::New(ReasonField::encode(reason) |
-                    FlagsField::encode(flags));
+    return Smi::New(ReasonField::encode(reason) | FlagsField::encode(flags));
   }
 
-  class ReasonField :
-      public BitField<intptr_t, ICData::DeoptReasonId, 0, 8> { };
-  class FlagsField : public BitField<intptr_t, uint32_t, 8, 8> { };
+  class ReasonField : public BitField<intptr_t, ICData::DeoptReasonId, 0, 8> {};
+  class FlagsField : public BitField<intptr_t, uint32_t, 8, 8> {};
 
  private:
   static const intptr_t kEntrySize = 3;
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_DEOPT_INSTRUCTIONS_H_