*** This commit represents a complete reformatting of the LLDB source code

*** to conform to clang-format’s LLVM style.  This kind of mass change has
*** two obvious implications:

Firstly, merging this particular commit into a downstream fork may be a huge
effort.  Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit.  The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):

    find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
    find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;

The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.

Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit.  There are alternatives available that will attempt
to look through this change and find the appropriate prior commit.  YMMV.

llvm-svn: 280751

1 files changed, 123 insertions, 143 deletions

diff --git a/lldb/source/Target/ThreadPlanStepOverBreakpoint.cpp b/lldb/source/Target/ThreadPlanStepOverBreakpoint.cpp
index da0326bfa91..39641a06548 100644
--- a/lldb/source/Target/ThreadPlanStepOverBreakpoint.cpp
+++ b/lldb/source/Target/ThreadPlanStepOverBreakpoint.cpp
@@ -22,172 +22,152 @@ using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
-// ThreadPlanStepOverBreakpoint: Single steps over a breakpoint bp_site_sp at the pc.
+// ThreadPlanStepOverBreakpoint: Single steps over a breakpoint bp_site_sp at
+// the pc.
 //----------------------------------------------------------------------
 
-ThreadPlanStepOverBreakpoint::ThreadPlanStepOverBreakpoint (Thread &thread) :
-    ThreadPlan (ThreadPlan::eKindStepOverBreakpoint, "Step over breakpoint trap",
-                thread,
-                eVoteNo,
-                eVoteNoOpinion),  // We need to report the run since this happens
-                            // first in the thread plan stack when stepping
-                            // over a breakpoint
-    m_breakpoint_addr (LLDB_INVALID_ADDRESS),
-    m_auto_continue(false),
-    m_reenabled_breakpoint_site (false)
-
-{
-    m_breakpoint_addr = m_thread.GetRegisterContext()->GetPC();
-    m_breakpoint_site_id =  m_thread.GetProcess()->GetBreakpointSiteList().FindIDByAddress (m_breakpoint_addr);
-}
-
-ThreadPlanStepOverBreakpoint::~ThreadPlanStepOverBreakpoint ()
-{
-}
-
-void
-ThreadPlanStepOverBreakpoint::GetDescription (Stream *s, lldb::DescriptionLevel level)
-{
-    s->Printf("Single stepping past breakpoint site %" PRIu64 " at 0x%" PRIx64, m_breakpoint_site_id, (uint64_t)m_breakpoint_addr);
-}
-
-bool
-ThreadPlanStepOverBreakpoint::ValidatePlan (Stream *error)
-{
-    return true;
-}
-
-bool
-ThreadPlanStepOverBreakpoint::DoPlanExplainsStop (Event *event_ptr)
-{
-    StopInfoSP stop_info_sp = GetPrivateStopInfo ();
-    if (stop_info_sp)
-    {
-        // It's a little surprising that we stop here for a breakpoint hit.  However, when you single step ONTO a breakpoint
-        // we still want to call that a breakpoint hit, and trigger the actions, etc.  Otherwise you would see the
-        // PC at the breakpoint without having triggered the actions, then you'd continue, the PC wouldn't change,
-        // and you'd see the breakpoint hit, which would be odd.
-        // So the lower levels fake "step onto breakpoint address" and return that as a breakpoint.  So our trace
-        // step COULD appear as a breakpoint hit if the next instruction also contained a breakpoint.
-        StopReason reason = stop_info_sp->GetStopReason();
-
-        switch (reason)
-        {
-        case eStopReasonTrace:
-        case eStopReasonNone:
-            return true;
-        case eStopReasonBreakpoint:
-            // It's a little surprising that we stop here for a breakpoint hit.  However, when you single step ONTO a
-            // breakpoint we still want to call that a breakpoint hit, and trigger the actions, etc.  Otherwise you
-            // would see the PC at the breakpoint without having triggered the actions, then you'd continue, the PC
-            // wouldn't change, and you'd see the breakpoint hit, which would be odd.
-            // So the lower levels fake "step onto breakpoint address" and return that as a breakpoint hit.  So our trace
-            // step COULD appear as a breakpoint hit if the next instruction also contained a breakpoint.  We don't want
-            // to handle that, since we really don't know what to do with breakpoint hits.  But make sure we don't set
-            // ourselves to auto-continue or we'll wrench control away from the plans that can deal with this.
-            SetAutoContinue(false);
-            return false;
-        default:
-            return false;
-        }
+ThreadPlanStepOverBreakpoint::ThreadPlanStepOverBreakpoint(Thread &thread)
+    : ThreadPlan(
+          ThreadPlan::eKindStepOverBreakpoint, "Step over breakpoint trap",
+          thread, eVoteNo,
+          eVoteNoOpinion), // We need to report the run since this happens
+                           // first in the thread plan stack when stepping
+                           // over a breakpoint
+      m_breakpoint_addr(LLDB_INVALID_ADDRESS),
+      m_auto_continue(false), m_reenabled_breakpoint_site(false)
+
+{
+  m_breakpoint_addr = m_thread.GetRegisterContext()->GetPC();
+  m_breakpoint_site_id =
+      m_thread.GetProcess()->GetBreakpointSiteList().FindIDByAddress(
+          m_breakpoint_addr);
+}
+
+ThreadPlanStepOverBreakpoint::~ThreadPlanStepOverBreakpoint() {}
+
+void ThreadPlanStepOverBreakpoint::GetDescription(
+    Stream *s, lldb::DescriptionLevel level) {
+  s->Printf("Single stepping past breakpoint site %" PRIu64 " at 0x%" PRIx64,
+            m_breakpoint_site_id, (uint64_t)m_breakpoint_addr);
+}
+
+bool ThreadPlanStepOverBreakpoint::ValidatePlan(Stream *error) { return true; }
+
+bool ThreadPlanStepOverBreakpoint::DoPlanExplainsStop(Event *event_ptr) {
+  StopInfoSP stop_info_sp = GetPrivateStopInfo();
+  if (stop_info_sp) {
+    // It's a little surprising that we stop here for a breakpoint hit.
+    // However, when you single step ONTO a breakpoint
+    // we still want to call that a breakpoint hit, and trigger the actions,
+    // etc.  Otherwise you would see the
+    // PC at the breakpoint without having triggered the actions, then you'd
+    // continue, the PC wouldn't change,
+    // and you'd see the breakpoint hit, which would be odd.
+    // So the lower levels fake "step onto breakpoint address" and return that
+    // as a breakpoint.  So our trace
+    // step COULD appear as a breakpoint hit if the next instruction also
+    // contained a breakpoint.
+    StopReason reason = stop_info_sp->GetStopReason();
+
+    switch (reason) {
+    case eStopReasonTrace:
+    case eStopReasonNone:
+      return true;
+    case eStopReasonBreakpoint:
+      // It's a little surprising that we stop here for a breakpoint hit.
+      // However, when you single step ONTO a
+      // breakpoint we still want to call that a breakpoint hit, and trigger the
+      // actions, etc.  Otherwise you
+      // would see the PC at the breakpoint without having triggered the
+      // actions, then you'd continue, the PC
+      // wouldn't change, and you'd see the breakpoint hit, which would be odd.
+      // So the lower levels fake "step onto breakpoint address" and return that
+      // as a breakpoint hit.  So our trace
+      // step COULD appear as a breakpoint hit if the next instruction also
+      // contained a breakpoint.  We don't want
+      // to handle that, since we really don't know what to do with breakpoint
+      // hits.  But make sure we don't set
+      // ourselves to auto-continue or we'll wrench control away from the plans
+      // that can deal with this.
+      SetAutoContinue(false);
+      return false;
+    default:
+      return false;
     }
-    return false;
+  }
+  return false;
 }
 
-bool
-ThreadPlanStepOverBreakpoint::ShouldStop (Event *event_ptr)
-{
-    return !ShouldAutoContinue(event_ptr);
+bool ThreadPlanStepOverBreakpoint::ShouldStop(Event *event_ptr) {
+  return !ShouldAutoContinue(event_ptr);
 }
 
-bool
-ThreadPlanStepOverBreakpoint::StopOthers ()
-{
-    return true;
-}
+bool ThreadPlanStepOverBreakpoint::StopOthers() { return true; }
 
-StateType
-ThreadPlanStepOverBreakpoint::GetPlanRunState ()
-{
-    return eStateStepping;
+StateType ThreadPlanStepOverBreakpoint::GetPlanRunState() {
+  return eStateStepping;
 }
 
-bool
-ThreadPlanStepOverBreakpoint::DoWillResume (StateType resume_state, bool current_plan)
-{
-    if (current_plan)
-    {
-        BreakpointSiteSP bp_site_sp (m_thread.GetProcess()->GetBreakpointSiteList().FindByAddress (m_breakpoint_addr));
-        if (bp_site_sp  && bp_site_sp->IsEnabled())
-            m_thread.GetProcess()->DisableBreakpointSite (bp_site_sp.get());
-    }
-    return true;
+bool ThreadPlanStepOverBreakpoint::DoWillResume(StateType resume_state,
+                                                bool current_plan) {
+  if (current_plan) {
+    BreakpointSiteSP bp_site_sp(
+        m_thread.GetProcess()->GetBreakpointSiteList().FindByAddress(
+            m_breakpoint_addr));
+    if (bp_site_sp && bp_site_sp->IsEnabled())
+      m_thread.GetProcess()->DisableBreakpointSite(bp_site_sp.get());
+  }
+  return true;
 }
 
-bool
-ThreadPlanStepOverBreakpoint::WillStop ()
-{
-    ReenableBreakpointSite ();
-    return true;
+bool ThreadPlanStepOverBreakpoint::WillStop() {
+  ReenableBreakpointSite();
+  return true;
 }
 
-bool
-ThreadPlanStepOverBreakpoint::MischiefManaged ()
-{
-    lldb::addr_t pc_addr = m_thread.GetRegisterContext()->GetPC();
+bool ThreadPlanStepOverBreakpoint::MischiefManaged() {
+  lldb::addr_t pc_addr = m_thread.GetRegisterContext()->GetPC();
 
-    if (pc_addr == m_breakpoint_addr)
-    {
-        // If we are still at the PC of our breakpoint, then for some reason we didn't
-        // get a chance to run.
-        return false;
-    }
-    else
-    {
-        Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
-        if (log)
-            log->Printf("Completed step over breakpoint plan.");
-        // Otherwise, re-enable the breakpoint we were stepping over, and we're done.
-        ReenableBreakpointSite ();
-        ThreadPlan::MischiefManaged ();
-        return true;
-    }
+  if (pc_addr == m_breakpoint_addr) {
+    // If we are still at the PC of our breakpoint, then for some reason we
+    // didn't
+    // get a chance to run.
+    return false;
+  } else {
+    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
+    if (log)
+      log->Printf("Completed step over breakpoint plan.");
+    // Otherwise, re-enable the breakpoint we were stepping over, and we're
+    // done.
+    ReenableBreakpointSite();
+    ThreadPlan::MischiefManaged();
+    return true;
+  }
 }
 
-void
-ThreadPlanStepOverBreakpoint::ReenableBreakpointSite ()
-{
-    if (!m_reenabled_breakpoint_site)
-    {
-        m_reenabled_breakpoint_site = true;
-        BreakpointSiteSP bp_site_sp (m_thread.GetProcess()->GetBreakpointSiteList().FindByAddress (m_breakpoint_addr));
-        if (bp_site_sp)
-        {
-            m_thread.GetProcess()->EnableBreakpointSite (bp_site_sp.get());
-        }
+void ThreadPlanStepOverBreakpoint::ReenableBreakpointSite() {
+  if (!m_reenabled_breakpoint_site) {
+    m_reenabled_breakpoint_site = true;
+    BreakpointSiteSP bp_site_sp(
+        m_thread.GetProcess()->GetBreakpointSiteList().FindByAddress(
+            m_breakpoint_addr));
+    if (bp_site_sp) {
+      m_thread.GetProcess()->EnableBreakpointSite(bp_site_sp.get());
     }
+  }
 }
-void
-ThreadPlanStepOverBreakpoint::ThreadDestroyed ()
-{
-    ReenableBreakpointSite ();
+void ThreadPlanStepOverBreakpoint::ThreadDestroyed() {
+  ReenableBreakpointSite();
 }
 
-void
-ThreadPlanStepOverBreakpoint::SetAutoContinue (bool do_it)
-{
-    m_auto_continue = do_it;
+void ThreadPlanStepOverBreakpoint::SetAutoContinue(bool do_it) {
+  m_auto_continue = do_it;
 }
 
-bool
-ThreadPlanStepOverBreakpoint::ShouldAutoContinue (Event *event_ptr)
-{
-    return m_auto_continue;
+bool ThreadPlanStepOverBreakpoint::ShouldAutoContinue(Event *event_ptr) {
+  return m_auto_continue;
 }
 
-bool
-ThreadPlanStepOverBreakpoint::IsPlanStale()
-{
-    return m_thread.GetRegisterContext()->GetPC() != m_breakpoint_addr;
+bool ThreadPlanStepOverBreakpoint::IsPlanStale() {
+  return m_thread.GetRegisterContext()->GetPC() != m_breakpoint_addr;
 }
-