*** 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, 269 insertions, 319 deletions

diff --git a/lldb/tools/lldb-perf/lib/TestCase.cpp b/lldb/tools/lldb-perf/lib/TestCase.cpp
index c23a5e51977..39394898996 100644
--- a/lldb/tools/lldb-perf/lib/TestCase.cpp
+++ b/lldb/tools/lldb-perf/lib/TestCase.cpp
@@ -13,346 +13,296 @@
 
 using namespace lldb_perf;
 
-TestCase::TestCase () :
-    m_debugger(),
-    m_target(),
-    m_process(),
-    m_thread(),
-    m_listener(),
-    m_verbose(false),
-    m_step(0)
-{
-    SBDebugger::Initialize();
-	SBHostOS::ThreadCreated ("<lldb-tester.app.main>");
-	m_debugger = SBDebugger::Create(false);
-	m_listener = m_debugger.GetListener();
-    m_listener.StartListeningForEventClass (m_debugger, SBProcess::GetBroadcasterClass(), SBProcess::eBroadcastBitStateChanged | SBProcess::eBroadcastBitInterrupt);
+TestCase::TestCase()
+    : m_debugger(), m_target(), m_process(), m_thread(), m_listener(),
+      m_verbose(false), m_step(0) {
+  SBDebugger::Initialize();
+  SBHostOS::ThreadCreated("<lldb-tester.app.main>");
+  m_debugger = SBDebugger::Create(false);
+  m_listener = m_debugger.GetListener();
+  m_listener.StartListeningForEventClass(
+      m_debugger, SBProcess::GetBroadcasterClass(),
+      SBProcess::eBroadcastBitStateChanged | SBProcess::eBroadcastBitInterrupt);
 }
 
-static std::string
-GetShortOptionString (struct option *long_options)
-{
-    std::string option_string;
-    for (int i = 0; long_options[i].name != NULL; ++i)
-    {
-        if (long_options[i].flag == NULL)
-        {
-            option_string.push_back ((char) long_options[i].val);
-            switch (long_options[i].has_arg)
-            {
-                default:
-                case no_argument:
-                    break;
-                case required_argument:
-                    option_string.push_back (':');
-                    break;
-                case optional_argument:
-                    option_string.append (2, ':');
-                    break;
-            }
-        }
+static std::string GetShortOptionString(struct option *long_options) {
+  std::string option_string;
+  for (int i = 0; long_options[i].name != NULL; ++i) {
+    if (long_options[i].flag == NULL) {
+      option_string.push_back((char)long_options[i].val);
+      switch (long_options[i].has_arg) {
+      default:
+      case no_argument:
+        break;
+      case required_argument:
+        option_string.push_back(':');
+        break;
+      case optional_argument:
+        option_string.append(2, ':');
+        break;
+      }
     }
-    return option_string;
+  }
+  return option_string;
 }
 
-bool
-TestCase::Setup (int& argc, const char**& argv)
-{
-    bool done = false;
-    
-    struct option* long_options = GetLongOptions();
-    
-    if (long_options)
-    {
-        std::string short_option_string (GetShortOptionString(long_options));
-        
-    #if __GLIBC__
-        optind = 0;
-    #else
-        optreset = 1;
-        optind = 1;
-    #endif
-        while (!done)
-        {
-            int long_options_index = -1;
-            const int short_option = ::getopt_long_only (argc,
-                                                         const_cast<char **>(argv),
-                                                         short_option_string.c_str(),
-                                                         long_options,
-                                                         &long_options_index);
-            
-            switch (short_option)
-            {
-                case 0:
-                    // Already handled
-                    break;
-                    
-                case -1:
-                    done = true;
-                    break;
-                    
-                default:
-                    done = !ParseOption(short_option, optarg);
-                    break;
-            }
-        }
-        argc -= optind;
-        argv += optind;
+bool TestCase::Setup(int &argc, const char **&argv) {
+  bool done = false;
+
+  struct option *long_options = GetLongOptions();
+
+  if (long_options) {
+    std::string short_option_string(GetShortOptionString(long_options));
+
+#if __GLIBC__
+    optind = 0;
+#else
+    optreset = 1;
+    optind = 1;
+#endif
+    while (!done) {
+      int long_options_index = -1;
+      const int short_option = ::getopt_long_only(
+          argc, const_cast<char **>(argv), short_option_string.c_str(),
+          long_options, &long_options_index);
+
+      switch (short_option) {
+      case 0:
+        // Already handled
+        break;
+
+      case -1:
+        done = true;
+        break;
+
+      default:
+        done = !ParseOption(short_option, optarg);
+        break;
+      }
     }
-    
-    return false;
-}
+    argc -= optind;
+    argv += optind;
+  }
 
-bool
-TestCase::Launch (lldb::SBLaunchInfo &launch_info)
-{
-    lldb::SBError error;
-	m_process = m_target.Launch (launch_info, error);
-    if (!error.Success())
-        fprintf (stderr, "error: %s\n", error.GetCString());
-    if (m_process.IsValid())
-        return true;
-    return false;
+  return false;
 }
 
-bool
-TestCase::Launch (std::initializer_list<const char*> args)
-{
-    std::vector<const char*> args_vect(args);
-    args_vect.push_back(NULL);
-    lldb::SBLaunchInfo launch_info((const char**)&args_vect[0]);
-    return Launch(launch_info);
+bool TestCase::Launch(lldb::SBLaunchInfo &launch_info) {
+  lldb::SBError error;
+  m_process = m_target.Launch(launch_info, error);
+  if (!error.Success())
+    fprintf(stderr, "error: %s\n", error.GetCString());
+  if (m_process.IsValid())
+    return true;
+  return false;
 }
 
-void
-TestCase::SetVerbose (bool b)
-{
-    m_verbose = b;
+bool TestCase::Launch(std::initializer_list<const char *> args) {
+  std::vector<const char *> args_vect(args);
+  args_vect.push_back(NULL);
+  lldb::SBLaunchInfo launch_info((const char **)&args_vect[0]);
+  return Launch(launch_info);
 }
 
-bool
-TestCase::GetVerbose ()
-{
-    return m_verbose;
-}
+void TestCase::SetVerbose(bool b) { m_verbose = b; }
+
+bool TestCase::GetVerbose() { return m_verbose; }
 
-void
-TestCase::Loop ()
-{
-	while (true)
-	{
-        bool call_test_step = false;
-        if (m_process.IsValid())
-        {
-            SBEvent evt;
-            m_listener.WaitForEvent (UINT32_MAX, evt);
-            StateType state = SBProcess::GetStateFromEvent (evt);
+void TestCase::Loop() {
+  while (true) {
+    bool call_test_step = false;
+    if (m_process.IsValid()) {
+      SBEvent evt;
+      m_listener.WaitForEvent(UINT32_MAX, evt);
+      StateType state = SBProcess::GetStateFromEvent(evt);
+      if (m_verbose)
+        printf("event = %s\n", SBDebugger::StateAsCString(state));
+      if (SBProcess::GetRestartedFromEvent(evt)) {
+        if (m_verbose) {
+          const uint32_t num_threads = m_process.GetNumThreads();
+          for (auto thread_index = 0; thread_index < num_threads;
+               thread_index++) {
+            SBThread thread(m_process.GetThreadAtIndex(thread_index));
+            SBFrame frame(thread.GetFrameAtIndex(0));
+            SBStream strm;
+            strm.RedirectToFileHandle(stdout, false);
+            frame.GetDescription(strm);
+          }
+          puts("restarted");
+        }
+        call_test_step = false;
+      } else {
+        switch (state) {
+        case eStateInvalid:
+        case eStateDetached:
+        case eStateCrashed:
+        case eStateUnloaded:
+          break;
+        case eStateExited:
+          return;
+        case eStateConnected:
+        case eStateAttaching:
+        case eStateLaunching:
+        case eStateRunning:
+        case eStateStepping:
+          call_test_step = false;
+          break;
+
+        case eStateStopped:
+        case eStateSuspended: {
+          call_test_step = true;
+          bool fatal = false;
+          bool selected_thread = false;
+          const uint32_t num_threads = m_process.GetNumThreads();
+          for (auto thread_index = 0; thread_index < num_threads;
+               thread_index++) {
+            SBThread thread(m_process.GetThreadAtIndex(thread_index));
+            SBFrame frame(thread.GetFrameAtIndex(0));
+            SBStream strm;
+            strm.RedirectToFileHandle(stdout, false);
+            frame.GetDescription(strm);
+            bool select_thread = false;
+            StopReason stop_reason = thread.GetStopReason();
             if (m_verbose)
-                printf("event = %s\n",SBDebugger::StateAsCString(state));
-            if (SBProcess::GetRestartedFromEvent(evt))
-            {
-                if (m_verbose)
-                {
-                    const uint32_t num_threads = m_process.GetNumThreads();
-                    for (auto thread_index = 0; thread_index < num_threads; thread_index++)
-                    {
-                        SBThread thread(m_process.GetThreadAtIndex(thread_index));
-                        SBFrame frame(thread.GetFrameAtIndex(0));
-                        SBStream strm;
-                        strm.RedirectToFileHandle(stdout, false);
-                        frame.GetDescription(strm);
-                    }
-                    puts("restarted");
-                }
-                call_test_step = false;
+              printf("tid = 0x%llx pc = 0x%llx ", thread.GetThreadID(),
+                     frame.GetPC());
+            switch (stop_reason) {
+            case eStopReasonNone:
+              if (m_verbose)
+                printf("none\n");
+              break;
+
+            case eStopReasonTrace:
+              select_thread = true;
+              if (m_verbose)
+                printf("trace\n");
+              break;
+
+            case eStopReasonPlanComplete:
+              select_thread = true;
+              if (m_verbose)
+                printf("plan complete\n");
+              break;
+            case eStopReasonThreadExiting:
+              if (m_verbose)
+                printf("thread exiting\n");
+              break;
+            case eStopReasonExec:
+              if (m_verbose)
+                printf("exec\n");
+              break;
+            case eStopReasonInvalid:
+              if (m_verbose)
+                printf("invalid\n");
+              break;
+            case eStopReasonException:
+              select_thread = true;
+              if (m_verbose)
+                printf("exception\n");
+              fatal = true;
+              break;
+            case eStopReasonBreakpoint:
+              select_thread = true;
+              if (m_verbose)
+                printf("breakpoint id = %lld.%lld\n",
+                       thread.GetStopReasonDataAtIndex(0),
+                       thread.GetStopReasonDataAtIndex(1));
+              break;
+            case eStopReasonWatchpoint:
+              select_thread = true;
+              if (m_verbose)
+                printf("watchpoint id = %lld\n",
+                       thread.GetStopReasonDataAtIndex(0));
+              break;
+            case eStopReasonSignal:
+              select_thread = true;
+              if (m_verbose)
+                printf("signal %d\n", (int)thread.GetStopReasonDataAtIndex(0));
+              break;
             }
-            else
-            {
-                switch (state)
-                {
-                case eStateInvalid:
-                case eStateDetached:
-                case eStateCrashed:
-                case eStateUnloaded:
-                    break;
-                case eStateExited:
-                    return;
-                case eStateConnected:
-                case eStateAttaching:
-                case eStateLaunching:
-                case eStateRunning:
-                case eStateStepping:
-                    call_test_step = false;
-                    break;
-        
-                case eStateStopped:
-                case eStateSuspended:
-                    {
-                        call_test_step = true;
-                        bool fatal = false;
-                        bool selected_thread = false;
-                        const uint32_t num_threads = m_process.GetNumThreads();
-                        for (auto thread_index = 0; thread_index < num_threads; thread_index++)
-                        {
-                            SBThread thread(m_process.GetThreadAtIndex(thread_index));
-                            SBFrame frame(thread.GetFrameAtIndex(0));
-                            SBStream strm;
-                            strm.RedirectToFileHandle(stdout, false);
-                            frame.GetDescription(strm);
-                            bool select_thread = false;
-                            StopReason stop_reason = thread.GetStopReason();
-                            if (m_verbose) printf("tid = 0x%llx pc = 0x%llx ",thread.GetThreadID(),frame.GetPC());
-                            switch (stop_reason)
-                            {
-                                case eStopReasonNone:
-                                    if (m_verbose)
-                                        printf("none\n");
-                                    break;
-                                    
-                                case eStopReasonTrace:
-                                    select_thread = true;
-                                    if (m_verbose)
-                                        printf("trace\n");
-                                    break;
-                                    
-                                case eStopReasonPlanComplete:
-                                    select_thread = true;
-                                    if (m_verbose)
-                                        printf("plan complete\n");
-                                    break;
-                                case eStopReasonThreadExiting:
-                                    if (m_verbose)
-                                        printf("thread exiting\n");
-                                    break;
-                                case eStopReasonExec:
-                                    if (m_verbose)
-                                        printf("exec\n");
-                                    break;
-                                case eStopReasonInvalid:
-                                    if (m_verbose)
-                                        printf("invalid\n");
-                                    break;
-                                case eStopReasonException:
-                                    select_thread = true;
-                                    if (m_verbose)
-                                        printf("exception\n");
-                                    fatal = true;
-                                    break;
-                                case eStopReasonBreakpoint:
-                                    select_thread = true;
-                                    if (m_verbose)
-                                        printf("breakpoint id = %lld.%lld\n",thread.GetStopReasonDataAtIndex(0),thread.GetStopReasonDataAtIndex(1));
-                                    break;
-                                case eStopReasonWatchpoint:
-                                    select_thread = true;
-                                    if (m_verbose)
-                                        printf("watchpoint id = %lld\n",thread.GetStopReasonDataAtIndex(0));
-                                    break;
-                                case eStopReasonSignal:
-                                    select_thread = true;
-                                    if (m_verbose)
-                                        printf("signal %d\n",(int)thread.GetStopReasonDataAtIndex(0));
-                                    break;
-                            }
-                            if (select_thread && !selected_thread)
-                            {
-                                m_thread = thread;
-                                selected_thread = m_process.SetSelectedThread(thread);
-                            }
-                        }
-                        if (fatal)
-                        {
-                            if (m_verbose) Xcode::RunCommand(m_debugger,"bt all",true);
-                            exit(1);
-                        }
-                    }
-                    break;
-                }
+            if (select_thread && !selected_thread) {
+              m_thread = thread;
+              selected_thread = m_process.SetSelectedThread(thread);
             }
-		}
-        else
-        {
-            call_test_step = true;
+          }
+          if (fatal) {
+            if (m_verbose)
+              Xcode::RunCommand(m_debugger, "bt all", true);
+            exit(1);
+          }
+        } break;
         }
+      }
+    } else {
+      call_test_step = true;
+    }
 
-        if (call_test_step)
-        {
-        do_the_call:
-            if (m_verbose)
-                printf("RUNNING STEP %d\n",m_step);
-            ActionWanted action;
-            TestStep(m_step, action);
-            m_step++;
-            SBError err;
-            switch (action.type)
-            {
-            case ActionWanted::Type::eNone:
-                // Just exit and wait for the next event
-                break;
-            case ActionWanted::Type::eContinue:
-                err = m_process.Continue();
-                break;
-            case ActionWanted::Type::eStepOut:
-                if (action.thread.IsValid() == false)
-                {
-                    if (m_verbose)
-                    {
-                        Xcode::RunCommand(m_debugger,"bt all",true);
-                        printf("error: invalid thread for step out on step %d\n", m_step);
-                    }
-                    exit(501);
-                }
-                m_process.SetSelectedThread(action.thread);
-                action.thread.StepOut();
-                break;
-            case ActionWanted::Type::eStepOver:
-                if (action.thread.IsValid() == false)
-                {
-                    if (m_verbose)
-                    {
-                        Xcode::RunCommand(m_debugger,"bt all",true);
-                        printf("error: invalid thread for step over %d\n",m_step);
-                    }
-                    exit(500);
-                }
-                m_process.SetSelectedThread(action.thread);
-                action.thread.StepOver();
-                break;
-            case ActionWanted::Type::eRelaunch:
-                if (m_process.IsValid())
-                {
-                    m_process.Kill();
-                    m_process.Clear();
-                }
-                Launch(action.launch_info);
-                break;
-            case ActionWanted::Type::eKill:
-                if (m_verbose)
-                    printf("kill\n");
-                m_process.Kill();
-                return;
-            case ActionWanted::Type::eCallNext:
-                goto do_the_call;
-                break;
-            }
+    if (call_test_step) {
+    do_the_call:
+      if (m_verbose)
+        printf("RUNNING STEP %d\n", m_step);
+      ActionWanted action;
+      TestStep(m_step, action);
+      m_step++;
+      SBError err;
+      switch (action.type) {
+      case ActionWanted::Type::eNone:
+        // Just exit and wait for the next event
+        break;
+      case ActionWanted::Type::eContinue:
+        err = m_process.Continue();
+        break;
+      case ActionWanted::Type::eStepOut:
+        if (action.thread.IsValid() == false) {
+          if (m_verbose) {
+            Xcode::RunCommand(m_debugger, "bt all", true);
+            printf("error: invalid thread for step out on step %d\n", m_step);
+          }
+          exit(501);
+        }
+        m_process.SetSelectedThread(action.thread);
+        action.thread.StepOut();
+        break;
+      case ActionWanted::Type::eStepOver:
+        if (action.thread.IsValid() == false) {
+          if (m_verbose) {
+            Xcode::RunCommand(m_debugger, "bt all", true);
+            printf("error: invalid thread for step over %d\n", m_step);
+          }
+          exit(500);
+        }
+        m_process.SetSelectedThread(action.thread);
+        action.thread.StepOver();
+        break;
+      case ActionWanted::Type::eRelaunch:
+        if (m_process.IsValid()) {
+          m_process.Kill();
+          m_process.Clear();
         }
+        Launch(action.launch_info);
+        break;
+      case ActionWanted::Type::eKill:
+        if (m_verbose)
+          printf("kill\n");
+        m_process.Kill();
+        return;
+      case ActionWanted::Type::eCallNext:
+        goto do_the_call;
+        break;
+      }
+    }
+  }
 
-	}
-    
-	if (GetVerbose()) printf("I am gonna die at step %d\n",m_step);
+  if (GetVerbose())
+    printf("I am gonna die at step %d\n", m_step);
 }
 
-int
-TestCase::Run (TestCase& test, int argc, const char** argv)
-{
-    if (test.Setup(argc, argv))
-    {
-        test.Loop();
-        Results results;
-        test.WriteResults(results);
-        return RUN_SUCCESS;
-    }
-    else
-        return RUN_SETUP_ERROR;
+int TestCase::Run(TestCase &test, int argc, const char **argv) {
+  if (test.Setup(argc, argv)) {
+    test.Loop();
+    Results results;
+    test.WriteResults(results);
+    return RUN_SUCCESS;
+  } else
+    return RUN_SETUP_ERROR;
 }
-