clang-format runtime/vm

runtime/vm/stack_frame.h

 // Copyright (c) 2011, 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_STACK_FRAME_H_
 #define RUNTIME_VM_STACK_FRAME_H_
 
 #include "vm/allocation.h"
 #include "vm/object.h"
 #include "vm/stub_code.h"
@@ skipping 17 matching lines @@
 namespace dart {
 
 // Forward declarations.
 class ObjectPointerVisitor;
 class RawContext;
 
 
 // Generic stack frame.
 class StackFrame : public ValueObject {
  public:
-  virtual ~StackFrame() { }
+  virtual ~StackFrame() {}
 
   // Accessors to get the pc, sp and fp of a frame.
   uword sp() const { return sp_; }
   uword fp() const { return fp_; }
   uword pc() const { return pc_; }
 
   // The pool pointer is not implemented on all architectures.
   static int SavedCallerPpSlotFromFp() {
     if (kSavedCallerPpSlotFromFp != kSavedCallerFpSlotFromFp) {
       return kSavedCallerPpSlotFromFp;
     }
     UNREACHABLE();
     return 0;
   }
 
   uword IsMarkedForLazyDeopt() const {
-    uword raw_pc = *reinterpret_cast<uword*>(
-        sp() + (kSavedPcSlotFromSp * kWordSize));
+    uword raw_pc =
+        *reinterpret_cast<uword*>(sp() + (kSavedPcSlotFromSp * kWordSize));
     return raw_pc == StubCode::DeoptimizeLazyFromReturn_entry()->EntryPoint();
   }
   void MarkForLazyDeopt() {
     set_pc(StubCode::DeoptimizeLazyFromReturn_entry()->EntryPoint());
   }
   void UnmarkForLazyDeopt() {
     // If this frame was marked for lazy deopt, pc_ was computed to be the
     // original return address using the pending deopts table in GetCallerPc.
     // Write this value back into the frame.
     uword original_pc = pc();
@@ skipping 33 matching lines @@
   RawCode* LookupDartCode() const;
   bool FindExceptionHandler(Thread* thread,
                             uword* handler_pc,
                             bool* needs_stacktrace,
                             bool* is_catch_all) const;
   // Returns token_pos of the pc(), or -1 if none exists.
   TokenPosition GetTokenPos() const;
 
  protected:
   explicit StackFrame(Thread* thread)
-      : fp_(0), sp_(0), pc_(0), thread_(thread) { }
+      : fp_(0), sp_(0), pc_(0), thread_(thread) {}
 
   // Name of the frame, used for generic frame printing functionality.
-  virtual const char* GetName() const { return IsStubFrame()? "stub" : "dart"; }
+  virtual const char* GetName() const {
+    return IsStubFrame() ? "stub" : "dart";
+  }
 
   Isolate* isolate() const { return thread_->isolate(); }
 
   Thread* thread() const { return thread_; }
 
  private:
   RawCode* GetCodeObject() const;
 
-  uword GetCallerSp() const {
-    return fp() + (kCallerSpSlotFromFp * kWordSize);
-  }
+  uword GetCallerSp() const { return fp() + (kCallerSpSlotFromFp * kWordSize); }
 
   uword GetCallerFp() const {
-    return *(reinterpret_cast<uword*>(
-      fp() + (kSavedCallerFpSlotFromFp * kWordSize)));
+    return *(reinterpret_cast<uword*>(fp() +
+                                      (kSavedCallerFpSlotFromFp * kWordSize)));
   }
 
   uword GetCallerPc() const {
     uword raw_pc = *(reinterpret_cast<uword*>(
         fp() + (kSavedCallerPcSlotFromFp * kWordSize)));
     ASSERT(raw_pc != StubCode::DeoptimizeLazyFromThrow_entry()->EntryPoint());
     if (raw_pc == StubCode::DeoptimizeLazyFromReturn_entry()->EntryPoint()) {
       return isolate()->FindPendingDeopt(GetCallerFp());
     }
     return raw_pc;
@@ skipping 21 matching lines @@
   bool IsStubFrame() const { return false; }
   bool IsExitFrame() const { return true; }
 
   // Visit objects in the frame.
   virtual void VisitObjectPointers(ObjectPointerVisitor* visitor);
 
  protected:
   virtual const char* GetName() const { return "exit"; }
 
  private:
-  explicit ExitFrame(Thread* thread) : StackFrame(thread) { }
+  explicit ExitFrame(Thread* thread) : StackFrame(thread) {}
 
   friend class StackFrameIterator;
   DISALLOW_COPY_AND_ASSIGN(ExitFrame);
 };
 
 
 // Entry Frame is used to mark the transition from dart VM runtime code into
 // dart code.
 class EntryFrame : public StackFrame {
  public:
-  bool IsValid() const {
-    return StubCode::InInvocationStub(pc());
-  }
+  bool IsValid() const { return StubCode::InInvocationStub(pc()); }
   bool IsDartFrame(bool validate = true) const { return false; }
   bool IsStubFrame() const { return false; }
   bool IsEntryFrame() const { return true; }
 
   // Visit objects in the frame.
   virtual void VisitObjectPointers(ObjectPointerVisitor* visitor);
 
  protected:
   virtual const char* GetName() const { return "entry"; }
 
  private:
-  explicit EntryFrame(Thread* thread) : StackFrame(thread) { }
+  explicit EntryFrame(Thread* thread) : StackFrame(thread) {}
 
   friend class StackFrameIterator;
   DISALLOW_COPY_AND_ASSIGN(EntryFrame);
 };
 
 
 // A StackFrameIterator can be initialized with a thread other than the
 // current thread. Because this is generally a bad idea, it is only allowed on
 // Windows- where it is needed for the profiler. It is the responsibility of
 // users of StackFrameIterator to ensure that the thread given is not running
 // concurrently.
 class StackFrameIterator : public ValueObject {
  public:
   static const bool kValidateFrames = true;
   static const bool kDontValidateFrames = false;
 
   // Iterators for iterating over all frames from the last ExitFrame to the
   // first EntryFrame.
-  StackFrameIterator(bool validate,
-                     Thread* thread = Thread::Current());
-  StackFrameIterator(uword last_fp, bool validate,
+  explicit StackFrameIterator(bool validate,
+                              Thread* thread = Thread::Current());
+  StackFrameIterator(uword last_fp,
+                     bool validate,
                      Thread* thread = Thread::Current());
 
 #if !defined(TARGET_ARCH_DBC)
   // Iterator for iterating over all frames from the current frame (given by its
   // fp, sp, and pc) to the first EntryFrame.
-  StackFrameIterator(uword fp, uword sp, uword pc, bool validate,
+  StackFrameIterator(uword fp,
+                     uword sp,
+                     uword pc,
+                     bool validate,
                      Thread* thread = Thread::Current());
 #endif
 
   // Checks if a next frame exists.
   bool HasNextFrame() const { return frames_.fp_ != 0; }
 
   // Get next frame.
   StackFrame* NextFrame();
 
   bool validate() const { return validate_; }
 
  private:
   // Iterator for iterating over the set of frames (dart or stub) which exist
   // in one EntryFrame and ExitFrame block.
   class FrameSetIterator : public ValueObject {
    public:
     // Checks if a next non entry/exit frame exists in the set.
     bool HasNext() const {
       if (fp_ == 0) {
         return false;
       }
-      const uword pc = *(reinterpret_cast<uword*>(
-          sp_ + (kSavedPcSlotFromSp * kWordSize)));
+      const uword pc =
+          *(reinterpret_cast<uword*>(sp_ + (kSavedPcSlotFromSp * kWordSize)));
       return !StubCode::InInvocationStub(pc);
     }
 
     // Get next non entry/exit frame in the set (assumes a next frame exists).
     StackFrame* NextFrame(bool validate);
 
    private:
     explicit FrameSetIterator(Thread* thread)
-        : fp_(0), sp_(0), pc_(0), stack_frame_(thread), thread_(thread) { }
+        : fp_(0), sp_(0), pc_(0), stack_frame_(thread), thread_(thread) {}
     uword fp_;
     uword sp_;
     uword pc_;
     StackFrame stack_frame_;  // Singleton frame returned by NextFrame().
     Thread* thread_;
 
     friend class StackFrameIterator;
     DISALLOW_COPY_AND_ASSIGN(FrameSetIterator);
   };
 
   // Get next exit frame.
   ExitFrame* NextExitFrame();
 
   // Get next entry frame.
   EntryFrame* NextEntryFrame();
 
   // Get an iterator to the next set of frames between an entry and exit
   // frame.
   FrameSetIterator* NextFrameSet() { return &frames_; }
 
   // Setup last or next exit frames so that we are ready to iterate over
   // stack frames.
   void SetupLastExitFrameData();
   void SetupNextExitFrameData();
 
-  bool validate_;  // Validate each frame as we traverse the frames.
+  bool validate_;     // Validate each frame as we traverse the frames.
   EntryFrame entry_;  // Singleton entry frame returned by NextEntryFrame().
-  ExitFrame exit_;  // Singleton exit frame returned by NextExitFrame().
+  ExitFrame exit_;    // Singleton exit frame returned by NextExitFrame().
   FrameSetIterator frames_;
   StackFrame* current_frame_;  // Points to the current frame in the iterator.
   Thread* thread_;
 
   DISALLOW_COPY_AND_ASSIGN(StackFrameIterator);
 };
 
 
 // Iterator for iterating over all dart frames (skips over exit frames,
 // entry frames and stub frames).
 // A DartFrameIterator can be initialized with an isolate other than the
 // current thread's isolate. Because this is generally a bad idea,
 // it is only allowed on Windows- where it is needed for the profiler.
 // It is the responsibility of users of DartFrameIterator to ensure that the
 // isolate given is not running concurrently on another thread.
 class DartFrameIterator : public ValueObject {
  public:
   explicit DartFrameIterator(Thread* thread = Thread::Current())
-      : frames_(StackFrameIterator::kDontValidateFrames, thread) { }
-  DartFrameIterator(uword last_fp,
-                    Thread* thread = Thread::Current())
-      : frames_(last_fp, StackFrameIterator::kDontValidateFrames, thread) { }
+      : frames_(StackFrameIterator::kDontValidateFrames, thread) {}
+  explicit DartFrameIterator(uword last_fp, Thread* thread = Thread::Current())
+      : frames_(last_fp, StackFrameIterator::kDontValidateFrames, thread) {}
 
 #if !defined(TARGET_ARCH_DBC)
   DartFrameIterator(uword fp,
                     uword sp,
                     uword pc,
                     Thread* thread = Thread::Current())
-      : frames_(fp, sp, pc,
-                StackFrameIterator::kDontValidateFrames, thread) {
-  }
+      : frames_(fp, sp, pc, StackFrameIterator::kDontValidateFrames, thread) {}
 #endif
 
   // Get next dart frame.
   StackFrame* NextFrame() {
     StackFrame* frame = frames_.NextFrame();
     while (frame != NULL && !frame->IsDartFrame(frames_.validate())) {
       frame = frames_.NextFrame();
     }
     return frame;
   }
@@ skipping 77 matching lines @@
 
 
 DART_FORCE_INLINE static uword LocalVarAddress(uword fp, intptr_t index) {
   return fp + LocalVarIndex(0, index) * kWordSize;
 }
 
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_STACK_FRAME_H_