*** 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

22 files changed, 2555 insertions, 3200 deletions

diff --git a/lldb/tools/lldb-perf/common/clang/lldb_perf_clang.cpp b/lldb/tools/lldb-perf/common/clang/lldb_perf_clang.cpp
index ac9481c..ccd7601 100644
--- a/lldb/tools/lldb-perf/common/clang/lldb_perf_clang.cpp
+++ b/lldb/tools/lldb-perf/common/clang/lldb_perf_clang.cpp
@@ -7,107 +7,99 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "lldb-perf/lib/Timer.h"
-#include "lldb-perf/lib/Metric.h"
 #include "lldb-perf/lib/Measurement.h"
+#include "lldb-perf/lib/Metric.h"
 #include "lldb-perf/lib/Results.h"
 #include "lldb-perf/lib/TestCase.h"
+#include "lldb-perf/lib/Timer.h"
 #include "lldb-perf/lib/Xcode.h"
 #include "llvm/ADT/STLExtras.h"
-#include <iostream>
-#include <unistd.h>
 #include <fstream>
 #include <getopt.h>
+#include <iostream>
+#include <unistd.h>
 
 using namespace lldb_perf;
 
 #define NUM_EXPR_ITERATIONS 3
-class ClangTest : public TestCase
-{
+class ClangTest : public TestCase {
 public:
-    ClangTest () :
-        TestCase(),
-        m_time_create_target ([this] () -> void
-                              {
-                                  m_memory_change_create_target.Start();
-                                  m_target = m_debugger.CreateTarget(m_exe_path.c_str());
-                                  m_memory_change_create_target.Stop();
-                              }, "time-create-target", "The time it takes to create a target."),
-        m_time_set_bp_main([this] () -> void
-                              {
-                                  m_memory_change_break_main.Start();
-                                  m_target.BreakpointCreateByName("main");
-                                  m_memory_change_break_main.Stop();
-                              }, "time-set-break-main", "Elapsed time it takes to set a breakpoint at 'main' by name."),
-        m_memory_change_create_target (),
-        m_memory_change_break_main (),
-        m_memory_total (),
-        m_time_launch_stop_main(),
-        m_time_total (),
-        m_expr_first_evaluate([this] (SBFrame frame) -> void
-                          {
-                              frame.EvaluateExpression("Diags.DiagArgumentsStr[0].size()").GetError();
-                          }, "time-expr", "Elapsed time it takes to evaluate an expression for the first time."),
-        m_expr_frame_zero ([this] (SBFrame frame) -> void
-                       {
-                           frame.EvaluateExpression("Diags.DiagArgumentsStr[0].size()").GetError();
-                       }, "time-expr-frame-zero", "Elapsed time it takes to evaluate an expression 3 times at frame zero."),
-        m_expr_frame_non_zero ([this] (SBFrame frame) -> void
-                           {
-                               frame.EvaluateExpression("Diags.DiagArgumentsStr[0].size()").GetError();
-                           }, "time-expr-frame-non-zero", "Elapsed time it takes to evaluate an expression 3 times at a non-zero frame."),
-        m_exe_path(),
-        m_out_path(),
-        m_launch_info (NULL),
-        m_use_dsym (false)
-    {
-    }
-
-    virtual
-    ~ClangTest ()
-    {
-    }
-    
-    virtual bool
-	Setup (int& argc, const char**& argv)
-    {
-        if (m_exe_path.empty())
-            return false;
-        m_launch_info.SetArguments(argv, false);
-        return true;
-    }
-    
-    void
-    DoTest ()
-    {
-    }
-    
-	virtual void
-	TestStep (int counter, ActionWanted &next_action)
-    {
-        char temp_source_path[PATH_MAX] = "/tmp/main.XXXXXX.cpp";
-
-        switch (counter)
-        {
-            case 0:
-                {
-                    //Xcode::RunCommand(m_debugger,"log enable -f /tmp/packets.txt gdb-remote packets",true);
-
-                    m_memory_total.Start();
-                    m_time_total.Start();
-                    
-                    // Time creating the target
-                    m_time_create_target();
-                    
-                    m_time_set_bp_main();
-
-                    int fd = mkstemps(temp_source_path, 4);
-
-                    if (fd >= 0)
-                    {
-                        const char *source_content = R"(
-#include <stdio.h>
+  ClangTest()
+      : TestCase(),
+        m_time_create_target(
+            [this]() -> void {
+              m_memory_change_create_target.Start();
+              m_target = m_debugger.CreateTarget(m_exe_path.c_str());
+              m_memory_change_create_target.Stop();
+            },
+            "time-create-target", "The time it takes to create a target."),
+        m_time_set_bp_main(
+            [this]() -> void {
+              m_memory_change_break_main.Start();
+              m_target.BreakpointCreateByName("main");
+              m_memory_change_break_main.Stop();
+            },
+            "time-set-break-main",
+            "Elapsed time it takes to set a breakpoint at 'main' by name."),
+        m_memory_change_create_target(), m_memory_change_break_main(),
+        m_memory_total(), m_time_launch_stop_main(), m_time_total(),
+        m_expr_first_evaluate(
+            [this](SBFrame frame) -> void {
+              frame.EvaluateExpression("Diags.DiagArgumentsStr[0].size()")
+                  .GetError();
+            },
+            "time-expr", "Elapsed time it takes to evaluate an expression for "
+                         "the first time."),
+        m_expr_frame_zero(
+            [this](SBFrame frame) -> void {
+              frame.EvaluateExpression("Diags.DiagArgumentsStr[0].size()")
+                  .GetError();
+            },
+            "time-expr-frame-zero", "Elapsed time it takes to evaluate an "
+                                    "expression 3 times at frame zero."),
+        m_expr_frame_non_zero(
+            [this](SBFrame frame) -> void {
+              frame.EvaluateExpression("Diags.DiagArgumentsStr[0].size()")
+                  .GetError();
+            },
+            "time-expr-frame-non-zero", "Elapsed time it takes to evaluate an "
+                                        "expression 3 times at a non-zero "
+                                        "frame."),
+        m_exe_path(), m_out_path(), m_launch_info(NULL), m_use_dsym(false) {}
+
+  virtual ~ClangTest() {}
+
+  virtual bool Setup(int &argc, const char **&argv) {
+    if (m_exe_path.empty())
+      return false;
+    m_launch_info.SetArguments(argv, false);
+    return true;
+  }
+
+  void DoTest() {}
+
+  virtual void TestStep(int counter, ActionWanted &next_action) {
+    char temp_source_path[PATH_MAX] = "/tmp/main.XXXXXX.cpp";
+
+    switch (counter) {
+    case 0: {
+      // Xcode::RunCommand(m_debugger,"log enable -f /tmp/packets.txt gdb-remote
+      // packets",true);
+
+      m_memory_total.Start();
+      m_time_total.Start();
+
+      // Time creating the target
+      m_time_create_target();
+
+      m_time_set_bp_main();
+
+      int fd = mkstemps(temp_source_path, 4);
+
+      if (fd >= 0) {
+        const char *source_content = R"(
 #include <stdint.h>
+#include <stdio.h>
 #include <vector>
                         
 namespace {
@@ -132,331 +124,299 @@ int main (int argc, char const *argv[], char const *envp[])
     return 0;
 }
 )";
-                        write (fd, source_content, strlen(source_content));
-                        close(fd);
-                    }
-                    else
-                    {
-                        const char *error_cstr = strerror(errno);
-                        fprintf (stderr, "error: failed to created temporary source file: '%s' (%s)", temp_source_path, error_cstr);
-                        exit(2);
-                    }
-
-                    m_time_launch_stop_main.Start();
-                    const char *clang_argv[] = {
-                        "-cc1",
-                        "-triple", "x86_64-apple-macosx10.8.0",
-                        "-emit-obj",
-                        "-mrelax-all",
-                        "-disable-free",
-                        "-disable-llvm-verifier",
-                        "-main-file-name", "main.cpp",
-                        "-mrelocation-model", "pic",
-                        "-pic-level", "2",
-                        "-mdisable-fp-elim",
-                        "-masm-verbose",
-                        "-munwind-tables",
-                        "-target-cpu", "core2",
-                        "-target-linker-version", "132.10.1",
-                        "-v",
-                        "-g",
-                        "-O0",
-                        "-fdeprecated-macro",
-                        "-ferror-limit", "19",
-                        "-fmessage-length", "298",
-                        "-stack-protector", "1",
-                        "-mstackrealign",
-                        "-fblocks",
-                        "-fobjc-runtime=macosx-10.8.0",
-                        "-fobjc-dispatch-method=mixed",
-                        "-fencode-extended-block-signature",
-                        "-fcxx-exceptions",
-                        "-fexceptions",
-                        "-fdiagnostics-show-option",
-                        "-fcolor-diagnostics",
-                        "-backend-option",
-                        "-vectorize-loops",
-                        "-o", "/tmp/main.o",
-                        "-x", "c++",
-                        NULL,
-                        NULL };
-                    clang_argv[llvm::array_lengthof(clang_argv)-2] = temp_source_path;
-                    SBLaunchInfo launch_info(clang_argv);
-                    Launch (launch_info);
-                    next_action.None(); // Don't continue or do anything, just wait for next event...
-                }
-                break;
-            case 1:
-                {
-                    m_time_launch_stop_main.Stop();
-                    m_time_total.Stop();
-                    SBFrame frame (m_thread.GetFrameAtIndex(0));
-
-                    // Time the first expression evaluation
-                    m_expr_first_evaluate(frame);
-                    
-                    SBValue result;
-                    for (size_t i=0; i<NUM_EXPR_ITERATIONS; ++i)
-                    {
-                        m_expr_frame_zero(frame);
-                    }
-                    m_target.BreakpointCreateByName("DeclContext::lookup");
-                    next_action.Continue();
-                }
-                break;
-            case 2:
-                {
-                    SBFrame frame (m_thread.GetFrameAtIndex(21));
-                    SBValue result;
-                    for (size_t i=0; i<NUM_EXPR_ITERATIONS; ++i)
-                    {
-                        m_expr_frame_non_zero(frame);
-                    }
-                    next_action.Continue();
-                }
-                break;
-            default:
-                m_memory_total.Stop();
-                next_action.Kill();
-                break;
-        }
-    }
-    
-    void
-    WriteResults (Results &results)
-    {
-        Results::Dictionary& results_dict = results.GetDictionary();
-        
-        m_time_set_bp_main.WriteAverageAndStandardDeviation(results);
-        results_dict.Add ("memory-change-create-target",
-                          "Memory increase that occurs due to creating the target.",
-                          m_memory_change_create_target.GetDeltaValue().GetResult(NULL, NULL));
-        
-        results_dict.Add ("memory-change-break-main",
-                          "Memory increase that occurs due to setting a breakpoint at main by name.",
-                          m_memory_change_break_main.GetDeltaValue().GetResult(NULL, NULL));
-
-        m_time_create_target.WriteAverageAndStandardDeviation(results);
-        m_expr_first_evaluate.WriteAverageAndStandardDeviation(results);
-        m_expr_frame_zero.WriteAverageAndStandardDeviation(results);
-        m_expr_frame_non_zero.WriteAverageAndStandardDeviation(results);
-        results_dict.Add ("memory-total-break-main",
-                          "The total memory that the current process is using after setting the first breakpoint.",
-                          m_memory_total.GetStopValue().GetResult(NULL, NULL));
-        
-        results_dict.AddDouble("time-launch-stop-main",
-                               "The time it takes to launch the process and stop at main.",
-                               m_time_launch_stop_main.GetDeltaValue());
-
-        results_dict.AddDouble("time-total",
-                               "The time it takes to create the target, set breakpoint at main, launch clang and hit the breakpoint at main.",
-                               m_time_total.GetDeltaValue());
-        results.Write(GetResultFilePath());
-    }
-    
-    
-    
-    const char *
-    GetExecutablePath () const
-    {
-        if (m_exe_path.empty())
-            return NULL;
-        return m_exe_path.c_str();
-    }
-
-    const char *
-    GetResultFilePath () const
-    {
-        if (m_out_path.empty())
-            return NULL;
-        return m_out_path.c_str();
+        write(fd, source_content, strlen(source_content));
+        close(fd);
+      } else {
+        const char *error_cstr = strerror(errno);
+        fprintf(stderr,
+                "error: failed to created temporary source file: '%s' (%s)",
+                temp_source_path, error_cstr);
+        exit(2);
+      }
+
+      m_time_launch_stop_main.Start();
+      const char *clang_argv[] = {"-cc1",
+                                  "-triple",
+                                  "x86_64-apple-macosx10.8.0",
+                                  "-emit-obj",
+                                  "-mrelax-all",
+                                  "-disable-free",
+                                  "-disable-llvm-verifier",
+                                  "-main-file-name",
+                                  "main.cpp",
+                                  "-mrelocation-model",
+                                  "pic",
+                                  "-pic-level",
+                                  "2",
+                                  "-mdisable-fp-elim",
+                                  "-masm-verbose",
+                                  "-munwind-tables",
+                                  "-target-cpu",
+                                  "core2",
+                                  "-target-linker-version",
+                                  "132.10.1",
+                                  "-v",
+                                  "-g",
+                                  "-O0",
+                                  "-fdeprecated-macro",
+                                  "-ferror-limit",
+                                  "19",
+                                  "-fmessage-length",
+                                  "298",
+                                  "-stack-protector",
+                                  "1",
+                                  "-mstackrealign",
+                                  "-fblocks",
+                                  "-fobjc-runtime=macosx-10.8.0",
+                                  "-fobjc-dispatch-method=mixed",
+                                  "-fencode-extended-block-signature",
+                                  "-fcxx-exceptions",
+                                  "-fexceptions",
+                                  "-fdiagnostics-show-option",
+                                  "-fcolor-diagnostics",
+                                  "-backend-option",
+                                  "-vectorize-loops",
+                                  "-o",
+                                  "/tmp/main.o",
+                                  "-x",
+                                  "c++",
+                                  NULL,
+                                  NULL};
+      clang_argv[llvm::array_lengthof(clang_argv) - 2] = temp_source_path;
+      SBLaunchInfo launch_info(clang_argv);
+      Launch(launch_info);
+      next_action
+          .None(); // Don't continue or do anything, just wait for next event...
+    } break;
+    case 1: {
+      m_time_launch_stop_main.Stop();
+      m_time_total.Stop();
+      SBFrame frame(m_thread.GetFrameAtIndex(0));
+
+      // Time the first expression evaluation
+      m_expr_first_evaluate(frame);
+
+      SBValue result;
+      for (size_t i = 0; i < NUM_EXPR_ITERATIONS; ++i) {
+        m_expr_frame_zero(frame);
+      }
+      m_target.BreakpointCreateByName("DeclContext::lookup");
+      next_action.Continue();
+    } break;
+    case 2: {
+      SBFrame frame(m_thread.GetFrameAtIndex(21));
+      SBValue result;
+      for (size_t i = 0; i < NUM_EXPR_ITERATIONS; ++i) {
+        m_expr_frame_non_zero(frame);
+      }
+      next_action.Continue();
+    } break;
+    default:
+      m_memory_total.Stop();
+      next_action.Kill();
+      break;
     }
+  }
+
+  void WriteResults(Results &results) {
+    Results::Dictionary &results_dict = results.GetDictionary();
+
+    m_time_set_bp_main.WriteAverageAndStandardDeviation(results);
+    results_dict.Add(
+        "memory-change-create-target",
+        "Memory increase that occurs due to creating the target.",
+        m_memory_change_create_target.GetDeltaValue().GetResult(NULL, NULL));
+
+    results_dict.Add(
+        "memory-change-break-main", "Memory increase that occurs due to "
+                                    "setting a breakpoint at main by name.",
+        m_memory_change_break_main.GetDeltaValue().GetResult(NULL, NULL));
+
+    m_time_create_target.WriteAverageAndStandardDeviation(results);
+    m_expr_first_evaluate.WriteAverageAndStandardDeviation(results);
+    m_expr_frame_zero.WriteAverageAndStandardDeviation(results);
+    m_expr_frame_non_zero.WriteAverageAndStandardDeviation(results);
+    results_dict.Add("memory-total-break-main",
+                     "The total memory that the current process is using after "
+                     "setting the first breakpoint.",
+                     m_memory_total.GetStopValue().GetResult(NULL, NULL));
+
+    results_dict.AddDouble(
+        "time-launch-stop-main",
+        "The time it takes to launch the process and stop at main.",
+        m_time_launch_stop_main.GetDeltaValue());
+
+    results_dict.AddDouble(
+        "time-total", "The time it takes to create the target, set breakpoint "
+                      "at main, launch clang and hit the breakpoint at main.",
+        m_time_total.GetDeltaValue());
+    results.Write(GetResultFilePath());
+  }
+
+  const char *GetExecutablePath() const {
+    if (m_exe_path.empty())
+      return NULL;
+    return m_exe_path.c_str();
+  }
+
+  const char *GetResultFilePath() const {
+    if (m_out_path.empty())
+      return NULL;
+    return m_out_path.c_str();
+  }
+
+  void SetExecutablePath(const char *path) {
+    if (path && path[0])
+      m_exe_path = path;
+    else
+      m_exe_path.clear();
+  }
+
+  void SetResultFilePath(const char *path) {
+    if (path && path[0])
+      m_out_path = path;
+    else
+      m_out_path.clear();
+  }
+
+  void SetUseDSYM(bool b) { m_use_dsym = b; }
 
-    void
-    SetExecutablePath (const char *path)
-    {
-        if (path && path[0])
-            m_exe_path = path;
-        else
-            m_exe_path.clear();
-    }
-    
-    void
-    SetResultFilePath (const char *path)
-    {
-        if (path && path[0])
-            m_out_path = path;
-        else
-            m_out_path.clear();
-    }
-
-    void
-    SetUseDSYM (bool b)
-    {
-        m_use_dsym = b;
-    }
-
-
-    
 private:
-    // C++ formatters
-    TimeMeasurement<std::function<void()>> m_time_create_target;
-    TimeMeasurement<std::function<void()>> m_time_set_bp_main;
-    MemoryGauge m_memory_change_create_target;
-    MemoryGauge m_memory_change_break_main;
-    MemoryGauge m_memory_total;
-    TimeGauge m_time_launch_stop_main;
-    TimeGauge m_time_total;
-    TimeMeasurement<std::function<void(SBFrame)>> m_expr_first_evaluate;
-    TimeMeasurement<std::function<void(SBFrame)>> m_expr_frame_zero;
-    TimeMeasurement<std::function<void(SBFrame)>> m_expr_frame_non_zero;
-    std::string m_exe_path;
-    std::string m_out_path;
-    SBLaunchInfo m_launch_info;
-    bool m_use_dsym;
-
+  // C++ formatters
+  TimeMeasurement<std::function<void()>> m_time_create_target;
+  TimeMeasurement<std::function<void()>> m_time_set_bp_main;
+  MemoryGauge m_memory_change_create_target;
+  MemoryGauge m_memory_change_break_main;
+  MemoryGauge m_memory_total;
+  TimeGauge m_time_launch_stop_main;
+  TimeGauge m_time_total;
+  TimeMeasurement<std::function<void(SBFrame)>> m_expr_first_evaluate;
+  TimeMeasurement<std::function<void(SBFrame)>> m_expr_frame_zero;
+  TimeMeasurement<std::function<void(SBFrame)>> m_expr_frame_non_zero;
+  std::string m_exe_path;
+  std::string m_out_path;
+  SBLaunchInfo m_launch_info;
+  bool m_use_dsym;
 };
 
+struct Options {
+  std::string clang_path;
+  std::string out_file;
+  bool verbose;
+  bool use_dsym;
+  bool error;
+  bool print_help;
 
-struct Options
-{
-    std::string clang_path;
-    std::string out_file;
-    bool verbose;
-    bool use_dsym;
-    bool error;
-    bool print_help;
-    
-    Options() :
-        verbose (false),
-        error (false),
-        print_help (false)
-    {
-    }
+  Options() : verbose(false), error(false), print_help(false) {}
 };
 
 static struct option g_long_options[] = {
-    { "verbose",    no_argument,            NULL, 'v' },
-    { "clang",      required_argument,      NULL, 'c' },
-    { "out-file",   required_argument,      NULL, 'o' },
-    { "dsym",       no_argument,            NULL, 'd' },
-    { NULL,         0,                      NULL,  0  }
-};
-
-
-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;
-            }
-        }
+    {"verbose", no_argument, NULL, 'v'},
+    {"clang", required_argument, NULL, 'c'},
+    {"out-file", required_argument, NULL, 'o'},
+    {"dsym", no_argument, NULL, 'd'},
+    {NULL, 0, NULL, 0}};
+
+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;
 }
 
-int main(int argc, const char * argv[])
-{
+int main(int argc, const char *argv[]) {
+
+  // Prepare for & make calls to getopt_long_only.
 
-    // Prepare for & make calls to getopt_long_only.
-    
-    std::string short_option_string (GetShortOptionString(g_long_options));
-    
-    ClangTest test;
+  std::string short_option_string(GetShortOptionString(g_long_options));
 
-    Options option_data;
-    bool done = false;
+  ClangTest test;
+
+  Options option_data;
+  bool done = false;
 
 #if __GLIBC__
-    optind = 0;
+  optind = 0;
 #else
-    optreset = 1;
-    optind = 1;
+  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(),
-                                                     g_long_options,
-                                                     &long_options_index);
-        
-        switch (short_option)
-        {
-            case 0:
-                // Already handled
-                break;
-
-            case -1:
-                done = true;
-                break;
-
-            case '?':
-                option_data.print_help = true;
-                break;
-
-            case 'h':
-                option_data.print_help = true;
-                break;
-                
-            case 'v':
-                option_data.verbose = true;
-                break;
-                
-            case 'c':
-                {
-                    SBFileSpec file(optarg);
-                    if (file.Exists())
-                        test.SetExecutablePath(optarg);
-                    else
-                        fprintf(stderr, "error: file specified in --clang (-c) option doesn't exist: '%s'\n", optarg);
-                }
-                break;
-                
-            case 'o':
-                test.SetResultFilePath(optarg);
-                break;
-                
-            case 'd':
-                test.SetUseDSYM(true);
-                break;
-                
-            default:
-                option_data.error = true;
-                option_data.print_help = true;
-                fprintf (stderr, "error: unrecognized option %c\n", short_option);
-                break;
-        }
+  while (!done) {
+    int long_options_index = -1;
+    const int short_option = ::getopt_long_only(
+        argc, const_cast<char **>(argv), short_option_string.c_str(),
+        g_long_options, &long_options_index);
+
+    switch (short_option) {
+    case 0:
+      // Already handled
+      break;
+
+    case -1:
+      done = true;
+      break;
+
+    case '?':
+      option_data.print_help = true;
+      break;
+
+    case 'h':
+      option_data.print_help = true;
+      break;
+
+    case 'v':
+      option_data.verbose = true;
+      break;
+
+    case 'c': {
+      SBFileSpec file(optarg);
+      if (file.Exists())
+        test.SetExecutablePath(optarg);
+      else
+        fprintf(stderr, "error: file specified in --clang (-c) option doesn't "
+                        "exist: '%s'\n",
+                optarg);
+    } break;
+
+    case 'o':
+      test.SetResultFilePath(optarg);
+      break;
+
+    case 'd':
+      test.SetUseDSYM(true);
+      break;
+
+    default:
+      option_data.error = true;
+      option_data.print_help = true;
+      fprintf(stderr, "error: unrecognized option %c\n", short_option);
+      break;
     }
+  }
 
+  if (test.GetExecutablePath() == NULL) {
+    // --clang is mandatory
+    option_data.print_help = true;
+    option_data.error = true;
+    fprintf(stderr, "error: the '--clang=PATH' option is mandatory\n");
+  }
 
-    if (test.GetExecutablePath() == NULL)
-    {
-        // --clang is mandatory
-        option_data.print_help = true;
-        option_data.error = true;
-        fprintf (stderr, "error: the '--clang=PATH' option is mandatory\n");
-    }
-
-    if (option_data.print_help)
-    {
-        puts(R"(
+  if (option_data.print_help) {
+    puts(R"(
 NAME
     lldb_perf_clang -- a tool that measures LLDB peformance while debugging clang.
 
@@ -467,18 +427,16 @@ DESCRIPTION
     Runs a set of static timing and memory tasks against clang and outputs results
     to a plist file.
 )");
-    }
-    if (option_data.error)
-    {
-        exit(1);
-    }
-
-    // Update argc and argv after parsing options
-    argc -= optind;
-    argv += optind;
-
-    test.SetVerbose(true);
-    TestCase::Run(test, argc, argv);
-    return 0;
+  }
+  if (option_data.error) {
+    exit(1);
+  }
+
+  // Update argc and argv after parsing options
+  argc -= optind;
+  argv += optind;
+
+  test.SetVerbose(true);
+  TestCase::Run(test, argc, argv);
+  return 0;
 }
-
diff --git a/lldb/tools/lldb-perf/common/clang/main.cpp b/lldb/tools/lldb-perf/common/clang/main.cpp
index 709c394..318a26b 100644
--- a/lldb/tools/lldb-perf/common/clang/main.cpp
+++ b/lldb/tools/lldb-perf/common/clang/main.cpp
@@ -1,24 +1,20 @@
-#include <stdio.h>
 #include <stdint.h>
+#include <stdio.h>
 #include <vector>
 
 namespace {
-    struct Foo
-    {
-        int i; int j;
-    };
-    void doit (const Foo &foo)
-    {
-        printf ("doit(%i)\n", foo.i);
-    }
+struct Foo {
+  int i;
+  int j;
+};
+void doit(const Foo &foo) { printf("doit(%i)\n", foo.i); }
 }
-int main (int argc, char const *argv[], char const *envp[])
-{
-    std::vector<int> ints;
-    for (int i=0;i<10;++i)
-        ints.push_back(i);
-    printf ("hello world\n");
-    Foo foo = { 12, 13 };
-    doit (foo);
-    return 0;
+int main(int argc, char const *argv[], char const *envp[]) {
+  std::vector<int> ints;
+  for (int i = 0; i < 10; ++i)
+    ints.push_back(i);
+  printf("hello world\n");
+  Foo foo = {12, 13};
+  doit(foo);
+  return 0;
 }
diff --git a/lldb/tools/lldb-perf/common/stepping/lldb-perf-stepping.cpp b/lldb/tools/lldb-perf/common/stepping/lldb-perf-stepping.cpp
index bb607ef..0df8bdc 100644
--- a/lldb/tools/lldb-perf/common/stepping/lldb-perf-stepping.cpp
+++ b/lldb/tools/lldb-perf/common/stepping/lldb-perf-stepping.cpp
@@ -1,305 +1,259 @@
 #include <CoreFoundation/CoreFoundation.h>
 
-#include "lldb-perf/lib/Timer.h"
-#include "lldb-perf/lib/Metric.h"
 #include "lldb-perf/lib/Measurement.h"
+#include "lldb-perf/lib/Metric.h"
 #include "lldb-perf/lib/TestCase.h"
+#include "lldb-perf/lib/Timer.h"
 #include "lldb-perf/lib/Xcode.h"
 
-#include <unistd.h>
-#include <string>
 #include <getopt.h>
+#include <string>
+#include <unistd.h>
 
 using namespace lldb_perf;
 
-class StepTest : public TestCase
-{
-    typedef void (*no_function) (void);
-    
+class StepTest : public TestCase {
+  typedef void (*no_function)(void);
+
 public:
-    StepTest(bool use_single_stepping = false) :
-        m_main_source("stepping-testcase.cpp"),
+  StepTest(bool use_single_stepping = false)
+      : m_main_source("stepping-testcase.cpp"),
         m_use_single_stepping(use_single_stepping),
-        m_time_measurements(nullptr)
-    {
-    }
-    
-    virtual
-    ~StepTest() {}
-    
-    virtual bool
-    Setup (int& argc, const char**& argv)
-    {
-        TestCase::Setup (argc, argv);
-        
-        // Toggle the fast stepping command on or off as required.
-        const char *single_step_cmd = "settings set target.use-fast-stepping false";
-        const char *fast_step_cmd   = "settings set target.use-fast-stepping true";
-        const char *cmd_to_use;
-        
-        if (m_use_single_stepping)
-            cmd_to_use = single_step_cmd;
-        else
-            cmd_to_use = fast_step_cmd;
-        
-        SBCommandReturnObject return_object;
-        m_debugger.GetCommandInterpreter().HandleCommand(cmd_to_use,
-                                                         return_object);
-        if (!return_object.Succeeded())
-        {
-            if (return_object.GetError() != NULL)
-                printf ("Got an error running settings set: %s.\n", return_object.GetError());
-            else
-                printf ("Failed running settings set, no error.\n");
-        }
-
-        m_target = m_debugger.CreateTarget(m_app_path.c_str());
-        m_first_bp = m_target.BreakpointCreateBySourceRegex("Here is some code to stop at originally.", m_main_source);
-        
-        const char* file_arg = m_app_path.c_str();
-        const char* empty = nullptr;
-        const char* args[] = {file_arg, empty};
-        SBLaunchInfo launch_info (args);
-        
-        return Launch (launch_info);
+        m_time_measurements(nullptr) {}
+
+  virtual ~StepTest() {}
+
+  virtual bool Setup(int &argc, const char **&argv) {
+    TestCase::Setup(argc, argv);
+
+    // Toggle the fast stepping command on or off as required.
+    const char *single_step_cmd = "settings set target.use-fast-stepping false";
+    const char *fast_step_cmd = "settings set target.use-fast-stepping true";
+    const char *cmd_to_use;
+
+    if (m_use_single_stepping)
+      cmd_to_use = single_step_cmd;
+    else
+      cmd_to_use = fast_step_cmd;
+
+    SBCommandReturnObject return_object;
+    m_debugger.GetCommandInterpreter().HandleCommand(cmd_to_use, return_object);
+    if (!return_object.Succeeded()) {
+      if (return_object.GetError() != NULL)
+        printf("Got an error running settings set: %s.\n",
+               return_object.GetError());
+      else
+        printf("Failed running settings set, no error.\n");
     }
 
-    void
-    WriteResults (Results &results)
-    {
-        // Gotta turn off the last timer now.
-        m_individual_step_times.push_back(m_time_measurements.Stop());
-
-        size_t num_time_measurements = m_individual_step_times.size();
-        
-        Results::Dictionary& results_dict = results.GetDictionary();
-        const char *short_format_string = "step-time-%0.2d";
-        const size_t short_size = strlen(short_format_string) + 5;
-        char short_buffer[short_size];
-        const char *long_format_string  = "The time it takes for step %d in the step sequence.";
-        const size_t long_size = strlen(long_format_string) + 5;
-        char long_buffer[long_size];
-        
-        for (size_t i = 0; i < num_time_measurements; i++)
-        {
-            snprintf (short_buffer, short_size, short_format_string, i);
-            snprintf (long_buffer, long_size, long_format_string, i);
-            
-            results_dict.AddDouble(short_buffer,
-                                   long_buffer,
-                                   m_individual_step_times[i]);
-
-        }
-        results_dict.AddDouble ("total-time", "Total time spent stepping.", m_time_measurements.GetMetric().GetSum());
-        results_dict.AddDouble ("stddev-time", "StdDev of time spent stepping.", m_time_measurements.GetMetric().GetStandardDeviation());
-
-        results.Write(m_out_path.c_str());
-    }
-    
-
-    const char *
-    GetExecutablePath () const
-    {
-        if (m_app_path.empty())
-            return NULL;
-        return m_app_path.c_str();
-    }
+    m_target = m_debugger.CreateTarget(m_app_path.c_str());
+    m_first_bp = m_target.BreakpointCreateBySourceRegex(
+        "Here is some code to stop at originally.", m_main_source);
 
-    const char *
-    GetResultFilePath () const
-    {
-        if (m_out_path.empty())
-            return NULL;
-        return m_out_path.c_str();
-    }
+    const char *file_arg = m_app_path.c_str();
+    const char *empty = nullptr;
+    const char *args[] = {file_arg, empty};
+    SBLaunchInfo launch_info(args);
 
-    void
-    SetExecutablePath (const char *path)
-    {
-        if (path && path[0])
-            m_app_path = path;
-        else
-            m_app_path.clear();
-    }
-    
-    void
-    SetResultFilePath (const char *path)
-    {
-        if (path && path[0])
-            m_out_path = path;
-        else
-            m_out_path.clear();
-    }
-    
-    void
-    SetUseSingleStep (bool use_it)
-    {
-        m_use_single_stepping = use_it;
+    return Launch(launch_info);
+  }
+
+  void WriteResults(Results &results) {
+    // Gotta turn off the last timer now.
+    m_individual_step_times.push_back(m_time_measurements.Stop());
+
+    size_t num_time_measurements = m_individual_step_times.size();
+
+    Results::Dictionary &results_dict = results.GetDictionary();
+    const char *short_format_string = "step-time-%0.2d";
+    const size_t short_size = strlen(short_format_string) + 5;
+    char short_buffer[short_size];
+    const char *long_format_string =
+        "The time it takes for step %d in the step sequence.";
+    const size_t long_size = strlen(long_format_string) + 5;
+    char long_buffer[long_size];
+
+    for (size_t i = 0; i < num_time_measurements; i++) {
+      snprintf(short_buffer, short_size, short_format_string, i);
+      snprintf(long_buffer, long_size, long_format_string, i);
+
+      results_dict.AddDouble(short_buffer, long_buffer,
+                             m_individual_step_times[i]);
     }
+    results_dict.AddDouble("total-time", "Total time spent stepping.",
+                           m_time_measurements.GetMetric().GetSum());
+    results_dict.AddDouble(
+        "stddev-time", "StdDev of time spent stepping.",
+        m_time_measurements.GetMetric().GetStandardDeviation());
+
+    results.Write(m_out_path.c_str());
+  }
+
+  const char *GetExecutablePath() const {
+    if (m_app_path.empty())
+      return NULL;
+    return m_app_path.c_str();
+  }
+
+  const char *GetResultFilePath() const {
+    if (m_out_path.empty())
+      return NULL;
+    return m_out_path.c_str();
+  }
+
+  void SetExecutablePath(const char *path) {
+    if (path && path[0])
+      m_app_path = path;
+    else
+      m_app_path.clear();
+  }
+
+  void SetResultFilePath(const char *path) {
+    if (path && path[0])
+      m_out_path = path;
+    else
+      m_out_path.clear();
+  }
+
+  void SetUseSingleStep(bool use_it) { m_use_single_stepping = use_it; }
+
 private:
-    virtual void
-	TestStep (int counter, ActionWanted &next_action)
-    {
-        if (counter > 0)
-        {
-            m_individual_step_times.push_back(m_time_measurements.Stop());
-            
-        }
-
-        // Disable the breakpoint, just in case it gets multiple locations we don't want that confusing the stepping.
-        if (counter == 0)
-            m_first_bp.SetEnabled(false);
-
-        next_action.StepOver(m_process.GetThreadAtIndex(0));
-        m_time_measurements.Start();
-
-    
+  virtual void TestStep(int counter, ActionWanted &next_action) {
+    if (counter > 0) {
+      m_individual_step_times.push_back(m_time_measurements.Stop());
     }
-    
-    SBBreakpoint m_first_bp;
-    SBFileSpec   m_main_source;
-    TimeMeasurement<no_function> m_time_measurements;
-    std::vector<double>          m_individual_step_times;
-    bool m_use_single_stepping;
-    std::string m_app_path;
-    std::string m_out_path;
-    
 
+    // Disable the breakpoint, just in case it gets multiple locations we don't
+    // want that confusing the stepping.
+    if (counter == 0)
+      m_first_bp.SetEnabled(false);
+
+    next_action.StepOver(m_process.GetThreadAtIndex(0));
+    m_time_measurements.Start();
+  }
+
+  SBBreakpoint m_first_bp;
+  SBFileSpec m_main_source;
+  TimeMeasurement<no_function> m_time_measurements;
+  std::vector<double> m_individual_step_times;
+  bool m_use_single_stepping;
+  std::string m_app_path;
+  std::string m_out_path;
 };
 
-struct Options
-{
-    std::string test_file_path;
-    std::string out_file;
-    bool verbose;
-    bool fast_step;
-    bool error;
-    bool print_help;
-    
-    Options() :
-        verbose (false),
-        fast_step (true),
-        error (false),
-        print_help (false)
-    {
-    }
-};
+struct Options {
+  std::string test_file_path;
+  std::string out_file;
+  bool verbose;
+  bool fast_step;
+  bool error;
+  bool print_help;
 
-static struct option g_long_options[] = {
-    { "verbose",      no_argument,            NULL, 'v' },
-    { "single-step",  no_argument,            NULL, 's' },
-    { "test-file",    required_argument,      NULL, 't' },
-    { "out-file",     required_argument,      NULL, 'o' },
-    { NULL,           0,                      NULL,  0  }
+  Options()
+      : verbose(false), fast_step(true), error(false), print_help(false) {}
 };
 
-
-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 struct option g_long_options[] = {
+    {"verbose", no_argument, NULL, 'v'},
+    {"single-step", no_argument, NULL, 's'},
+    {"test-file", required_argument, NULL, 't'},
+    {"out-file", required_argument, NULL, 'o'},
+    {NULL, 0, NULL, 0}};
+
+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;
 }
 
-int main(int argc, const char * argv[])
-{
+int main(int argc, const char *argv[]) {
+
+  // Prepare for & make calls to getopt_long_only.
 
-    // Prepare for & make calls to getopt_long_only.
-    
-    std::string short_option_string (GetShortOptionString(g_long_options));
-    
-    StepTest test;
+  std::string short_option_string(GetShortOptionString(g_long_options));
 
-    Options option_data;
-    bool done = false;
+  StepTest test;
+
+  Options option_data;
+  bool done = false;
 
 #if __GLIBC__
-    optind = 0;
+  optind = 0;
 #else
-    optreset = 1;
-    optind = 1;
+  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(),
-                                                     g_long_options,
-                                                     &long_options_index);
-        
-        switch (short_option)
-        {
-            case 0:
-                // Already handled
-                break;
-
-            case -1:
-                done = true;
-                break;
-
-            case '?':
-                option_data.print_help = true;
-                break;
-
-            case 'h':
-                option_data.print_help = true;
-                break;
-                
-            case 'v':
-                option_data.verbose = true;
-                break;
-                
-            case 's':
-                option_data.fast_step = false;
-                test.SetUseSingleStep(true);
-                break;
-                
-            case 't':
-                {
-                    SBFileSpec file(optarg);
-                    if (file.Exists())
-                        test.SetExecutablePath(optarg);
-                    else
-                        fprintf(stderr, "error: file specified in --test-file (-t) option doesn't exist: '%s'\n", optarg);
-                }
-                break;
-                
-            case 'o':
-                test.SetResultFilePath(optarg);
-                break;
-                
-            default:
-                option_data.error = true;
-                option_data.print_help = true;
-                fprintf (stderr, "error: unrecognized option %c\n", short_option);
-                break;
-        }
+  while (!done) {
+    int long_options_index = -1;
+    const int short_option = ::getopt_long_only(
+        argc, const_cast<char **>(argv), short_option_string.c_str(),
+        g_long_options, &long_options_index);
+
+    switch (short_option) {
+    case 0:
+      // Already handled
+      break;
+
+    case -1:
+      done = true;
+      break;
+
+    case '?':
+      option_data.print_help = true;
+      break;
+
+    case 'h':
+      option_data.print_help = true;
+      break;
+
+    case 'v':
+      option_data.verbose = true;
+      break;
+
+    case 's':
+      option_data.fast_step = false;
+      test.SetUseSingleStep(true);
+      break;
+
+    case 't': {
+      SBFileSpec file(optarg);
+      if (file.Exists())
+        test.SetExecutablePath(optarg);
+      else
+        fprintf(stderr, "error: file specified in --test-file (-t) option "
+                        "doesn't exist: '%s'\n",
+                optarg);
+    } break;
+
+    case 'o':
+      test.SetResultFilePath(optarg);
+      break;
+
+    default:
+      option_data.error = true;
+      option_data.print_help = true;
+      fprintf(stderr, "error: unrecognized option %c\n", short_option);
+      break;
     }
+  }
 
-
-    if (option_data.print_help)
-    {
-        puts(R"(
+  if (option_data.print_help) {
+    puts(R"(
 NAME
     lldb-perf-stepping -- a tool that measures LLDB peformance of simple stepping operations.
 
@@ -310,26 +264,24 @@ DESCRIPTION
     Runs a set of stepping operations, timing each step and outputs results
     to a plist file.
 )");
-        exit(0);
-    }
-    if (option_data.error)
-    {
-        exit(1);
-    }
-
-    if (test.GetExecutablePath() == NULL)
-    {
-        // --clang is mandatory
-        option_data.print_help = true;
-        option_data.error = true;
-        fprintf (stderr, "error: the '--test-file=PATH' option is mandatory\n");
-    }
-
-    // Update argc and argv after parsing options
-    argc -= optind;
-    argv += optind;
-
-    test.SetVerbose(true);
-    TestCase::Run(test, argc, argv);
-    return 0;
+    exit(0);
+  }
+  if (option_data.error) {
+    exit(1);
+  }
+
+  if (test.GetExecutablePath() == NULL) {
+    // --clang is mandatory
+    option_data.print_help = true;
+    option_data.error = true;
+    fprintf(stderr, "error: the '--test-file=PATH' option is mandatory\n");
+  }
+
+  // Update argc and argv after parsing options
+  argc -= optind;
+  argv += optind;
+
+  test.SetVerbose(true);
+  TestCase::Run(test, argc, argv);
+  return 0;
 }
diff --git a/lldb/tools/lldb-perf/common/stepping/stepping-testcase.cpp b/lldb/tools/lldb-perf/common/stepping/stepping-testcase.cpp
index f842c23..50f0164 100644
--- a/lldb/tools/lldb-perf/common/stepping/stepping-testcase.cpp
+++ b/lldb/tools/lldb-perf/common/stepping/stepping-testcase.cpp
@@ -1,42 +1,35 @@
 #include <stdio.h>
-#include <vector>
 #include <string>
+#include <vector>
+
+struct struct_for_copying {
+  struct_for_copying(int in_int, double in_double, const char *in_string)
+      : int_value(in_int), double_value(in_double), string_value(in_string) {}
+  struct_for_copying() { struct_for_copying(0, 0, ""); }
 
-struct struct_for_copying
-{
-    struct_for_copying (int in_int, double in_double, const char *in_string) :
-        int_value(in_int),
-        double_value(in_double),
-        string_value (in_string)
-    {
-        
-    }
-    struct_for_copying()
-    {
-        struct_for_copying (0, 0, "");
-    }
-    
-    int int_value;
-    double double_value;
-    std::string string_value;
+  int int_value;
+  double double_value;
+  std::string string_value;
 };
 
-int main (int argc, char **argv)
-{
-    struct_for_copying input_struct (150 * argc, 10.0 * argc, argv[0]);
-    struct_for_copying output_struct;
-    int some_int = 44;
-    double some_double = 34.5;
-    double other_double;
-    size_t vector_size;
-    std::vector<struct_for_copying> my_vector;
-    
-    printf ("Here is some code to stop at originally.  Got: %d, %p.\n", argc, argv);
-    output_struct = input_struct;
-    other_double = (some_double * some_int)/((double) argc);
-    other_double = other_double > 0 ? some_double/other_double : some_double > 0 ? other_double/some_double : 10.0;
-    my_vector.push_back (input_struct);
-    vector_size = my_vector.size();
-    
-	return vector_size == 0 ? 0 : 1;
+int main(int argc, char **argv) {
+  struct_for_copying input_struct(150 * argc, 10.0 * argc, argv[0]);
+  struct_for_copying output_struct;
+  int some_int = 44;
+  double some_double = 34.5;
+  double other_double;
+  size_t vector_size;
+  std::vector<struct_for_copying> my_vector;
+
+  printf("Here is some code to stop at originally.  Got: %d, %p.\n", argc,
+         argv);
+  output_struct = input_struct;
+  other_double = (some_double * some_int) / ((double)argc);
+  other_double = other_double > 0
+                     ? some_double / other_double
+                     : some_double > 0 ? other_double / some_double : 10.0;
+  my_vector.push_back(input_struct);
+  vector_size = my_vector.size();
+
+  return vector_size == 0 ? 0 : 1;
 }
diff --git a/lldb/tools/lldb-perf/darwin/formatters/fmts_tester.mm b/lldb/tools/lldb-perf/darwin/formatters/fmts_tester.mm
index 57ce008..1915c4a 100644
--- a/lldb/tools/lldb-perf/darwin/formatters/fmts_tester.mm
+++ b/lldb/tools/lldb-perf/darwin/formatters/fmts_tester.mm
@@ -7,73 +7,76 @@
 //
 //===----------------------------------------------------------------------===//
 
-
 #import <Cocoa/Cocoa.h>
-#include <vector>
 #include <list>
 #include <map>
 #include <string>
+#include <vector>
 
-int main()
-{
-	NSArray* nsarray = @[@1,@2,@"hello world",@3,@4,@"foobar"];
-	NSMutableArray* nsmutablearray = [[NSMutableArray alloc] initWithCapacity:5];
-	[nsmutablearray addObject:@1];
-	[nsmutablearray addObject:@2];
-	[nsmutablearray addObject:@"hello world"];
-	[nsmutablearray addObject:@3];
-	[nsmutablearray addObject:@4];
-	[nsmutablearray addObject:@"foobar"];
-	NSDictionary* nsdictionary = @{@1 : @1, @2 : @2, @"hello" : @"world", @3 : @3};
-	NSMutableDictionary* nsmutabledictionary = [[NSMutableDictionary alloc] initWithCapacity:5];
-	[nsmutabledictionary setObject:@1 forKey:@1];
-	[nsmutabledictionary setObject:@2 forKey:@2];
-	[nsmutabledictionary setObject:@"hello" forKey:@"world"];
-	[nsmutabledictionary setObject:@3 forKey:@3];
-	NSString* str0 = @"Hello world";
-	NSString* str1 = @"Hello ℥";
-	NSString* str2 = @"Hello world";
-	NSString* str3 = @"Hello ℥";
-	NSString* str4 = @"Hello world";
-	NSDate* me = [NSDate dateWithNaturalLanguageString:@"April 10, 1985"];
-	NSDate* cutie = [NSDate dateWithNaturalLanguageString:@"January 29, 1983"];
-	NSDate* mom = [NSDate dateWithNaturalLanguageString:@"May 24, 1959"];
-	NSDate* dad = [NSDate dateWithNaturalLanguageString:@"October 29, 1954"];
-	NSDate* today = [NSDate dateWithNaturalLanguageString:@"March 14, 2013"];
-	NSArray* bundles = [NSBundle allBundles];
-	NSArray* frameworks = [NSBundle allFrameworks];
-	NSSet* nsset = [NSSet setWithArray:nsarray];
-	NSMutableSet* nsmutableset = [NSMutableSet setWithCapacity:5];
-	[nsmutableset addObject:@1];
-	[nsmutableset addObject:@2];
-	[nsmutableset addObject:@"hello world"];
-	[nsmutableset addObject:@3];
-	[nsmutableset addObject:@4];
-	[nsmutableset addObject:@"foobar"];
-	std::vector<int> vector;
-	vector.push_back(1);
-	vector.push_back(2);
-	vector.push_back(3);
-	vector.push_back(4);
-	vector.push_back(5);
-	std::list<int> list;
-	list.push_back(1);
-	list.push_back(2);
-	list.push_back(3);
-	list.push_back(4);
-	list.push_back(5);
-	std::map<int,int> map;
-	map[1] = 1;
-	map[2] = 2;
-	map[3] = 3;
-	map[4] = 4;
-	map[5] = 5;
-	std::string sstr0("Hello world");
-	std::string sstr1("Hello world");
-	std::string sstr2("Hello world");
-	std::string sstr3("Hello world");
-	std::string sstr4("Hello world");
-	int x = 0;
-	for (;;)
-		x++;
+int main() {
+  NSArray *nsarray = @[ @1, @2, @"hello world", @3, @4, @"foobar" ];
+  NSMutableArray *nsmutablearray = [[NSMutableArray alloc] initWithCapacity:5];
+  [nsmutablearray addObject:@1];
+  [nsmutablearray addObject:@2];
+  [nsmutablearray addObject:@"hello world"];
+  [nsmutablearray addObject:@3];
+  [nsmutablearray addObject:@4];
+  [nsmutablearray addObject:@"foobar"];
+  NSDictionary *nsdictionary =
+      @{ @1 : @1,
+         @2 : @2,
+         @"hello" : @"world",
+         @3 : @3 };
+  NSMutableDictionary *nsmutabledictionary =
+      [[NSMutableDictionary alloc] initWithCapacity:5];
+  [nsmutabledictionary setObject:@1 forKey:@1];
+  [nsmutabledictionary setObject:@2 forKey:@2];
+  [nsmutabledictionary setObject:@"hello" forKey:@"world"];
+  [nsmutabledictionary setObject:@3 forKey:@3];
+  NSString *str0 = @"Hello world";
+  NSString *str1 = @"Hello ℥";
+  NSString *str2 = @"Hello world";
+  NSString *str3 = @"Hello ℥";
+  NSString *str4 = @"Hello world";
+  NSDate *me = [NSDate dateWithNaturalLanguageString:@"April 10, 1985"];
+  NSDate *cutie = [NSDate dateWithNaturalLanguageString:@"January 29, 1983"];
+  NSDate *mom = [NSDate dateWithNaturalLanguageString:@"May 24, 1959"];
+  NSDate *dad = [NSDate dateWithNaturalLanguageString:@"October 29, 1954"];
+  NSDate *today = [NSDate dateWithNaturalLanguageString:@"March 14, 2013"];
+  NSArray *bundles = [NSBundle allBundles];
+  NSArray *frameworks = [NSBundle allFrameworks];
+  NSSet *nsset = [NSSet setWithArray:nsarray];
+  NSMutableSet *nsmutableset = [NSMutableSet setWithCapacity:5];
+  [nsmutableset addObject:@1];
+  [nsmutableset addObject:@2];
+  [nsmutableset addObject:@"hello world"];
+  [nsmutableset addObject:@3];
+  [nsmutableset addObject:@4];
+  [nsmutableset addObject:@"foobar"];
+  std::vector<int> vector;
+  vector.push_back(1);
+  vector.push_back(2);
+  vector.push_back(3);
+  vector.push_back(4);
+  vector.push_back(5);
+  std::list<int> list;
+  list.push_back(1);
+  list.push_back(2);
+  list.push_back(3);
+  list.push_back(4);
+  list.push_back(5);
+  std::map<int, int> map;
+  map[1] = 1;
+  map[2] = 2;
+  map[3] = 3;
+  map[4] = 4;
+  map[5] = 5;
+  std::string sstr0("Hello world");
+  std::string sstr1("Hello world");
+  std::string sstr2("Hello world");
+  std::string sstr3("Hello world");
+  std::string sstr4("Hello world");
+  int x = 0;
+  for (;;)
+    x++;
 }
\ No newline at end of file
diff --git a/lldb/tools/lldb-perf/darwin/formatters/formatters.cpp b/lldb/tools/lldb-perf/darwin/formatters/formatters.cpp
index ee38756..95524c4 100644
--- a/lldb/tools/lldb-perf/darwin/formatters/formatters.cpp
+++ b/lldb/tools/lldb-perf/darwin/formatters/formatters.cpp
@@ -9,238 +9,260 @@
 
 #include <CoreFoundation/CoreFoundation.h>
 
-#include "lldb-perf/lib/Timer.h"
-#include "lldb-perf/lib/Metric.h"
 #include "lldb-perf/lib/Measurement.h"
+#include "lldb-perf/lib/Metric.h"
 #include "lldb-perf/lib/TestCase.h"
+#include "lldb-perf/lib/Timer.h"
 #include "lldb-perf/lib/Xcode.h"
 
+#include <fstream>
 #include <iostream>
 #include <unistd.h>
-#include <fstream>
 
 using namespace lldb_perf;
 
-class FormattersTest : public TestCase
-{
+class FormattersTest : public TestCase {
 public:
-    FormattersTest () : TestCase()
-    {
-        m_dump_std_vector_measurement = CreateTimeMeasurement([] (SBValue value) -> void {
-            lldb_perf::Xcode::FetchVariable (value,1,false);
-        }, "std-vector", "time to dump an std::vector");
-        m_dump_std_list_measurement = CreateTimeMeasurement([] (SBValue value) -> void {
-            lldb_perf::Xcode::FetchVariable (value,1,false);
-        }, "std-list", "time to dump an std::list");
-        m_dump_std_map_measurement = CreateTimeMeasurement([] (SBValue value) -> void {
-            lldb_perf::Xcode::FetchVariable (value,1,false);
-        }, "std-map", "time to dump an std::map");
-        
-        // use this in manual mode
-        m_dump_std_string_measurement = CreateTimeMeasurement([] () -> void {
-        }, "std-string", "time to dump an std::string");
-        
-        m_dump_nsstring_measurement = CreateTimeMeasurement([] (SBValue value) -> void {
-            lldb_perf::Xcode::FetchVariable (value,0,false);
-        }, "ns-string", "time to dump an NSString");
-        
-        m_dump_nsarray_measurement = CreateTimeMeasurement([] (SBValue value) -> void {
-            lldb_perf::Xcode::FetchVariable (value,1,false);
-        }, "ns-array", "time to dump an NSArray");
-        
-        m_dump_nsdictionary_measurement = CreateTimeMeasurement([] (SBValue value) -> void {
-            lldb_perf::Xcode::FetchVariable (value,1,false);
-        }, "ns-dictionary", "time to dump an NSDictionary");
-        
-        m_dump_nsset_measurement = CreateTimeMeasurement([] (SBValue value) -> void {
-            lldb_perf::Xcode::FetchVariable (value,1,false);
-        }, "ns-set", "time to dump an NSSet");
-        
-        m_dump_nsbundle_measurement = CreateTimeMeasurement([] (SBValue value) -> void {
-            lldb_perf::Xcode::FetchVariable (value,1,false);
-        }, "ns-bundle", "time to dump an NSBundle");
-        
-        m_dump_nsdate_measurement = CreateTimeMeasurement([] (SBValue value) -> void {
-            lldb_perf::Xcode::FetchVariable (value,0,false);
-        }, "ns-date", "time to dump an NSDate");
-    }
+  FormattersTest() : TestCase() {
+    m_dump_std_vector_measurement = CreateTimeMeasurement(
+        [](SBValue value) -> void {
+          lldb_perf::Xcode::FetchVariable(value, 1, false);
+        },
+        "std-vector", "time to dump an std::vector");
+    m_dump_std_list_measurement = CreateTimeMeasurement(
+        [](SBValue value) -> void {
+          lldb_perf::Xcode::FetchVariable(value, 1, false);
+        },
+        "std-list", "time to dump an std::list");
+    m_dump_std_map_measurement = CreateTimeMeasurement(
+        [](SBValue value) -> void {
+          lldb_perf::Xcode::FetchVariable(value, 1, false);
+        },
+        "std-map", "time to dump an std::map");
 
-    virtual
-    ~FormattersTest ()
-    {
-    }
-    
-    virtual bool
-	Setup (int& argc, const char**& argv)
-    {
-        m_app_path.assign(argv[1]);
-        m_out_path.assign(argv[2]);
-        m_target = m_debugger.CreateTarget(m_app_path.c_str());
-        m_target.BreakpointCreateByName("main");
-        SBLaunchInfo launch_info(argv);
-        return Launch (launch_info);
-    }
-    
-    void
-    DoTest ()
-    {
-        SBFrame frame_zero(m_thread.GetFrameAtIndex(0));
-        
-        m_dump_nsarray_measurement(frame_zero.FindVariable("nsarray", lldb::eDynamicCanRunTarget));
-        m_dump_nsarray_measurement(frame_zero.FindVariable("nsmutablearray", lldb::eDynamicCanRunTarget));
-
-        m_dump_nsdictionary_measurement(frame_zero.FindVariable("nsdictionary", lldb::eDynamicCanRunTarget));
-        m_dump_nsdictionary_measurement(frame_zero.FindVariable("nsmutabledictionary", lldb::eDynamicCanRunTarget));
-        
-        m_dump_nsstring_measurement(frame_zero.FindVariable("str0", lldb::eDynamicCanRunTarget));
-        m_dump_nsstring_measurement(frame_zero.FindVariable("str1", lldb::eDynamicCanRunTarget));
-        m_dump_nsstring_measurement(frame_zero.FindVariable("str2", lldb::eDynamicCanRunTarget));
-        m_dump_nsstring_measurement(frame_zero.FindVariable("str3", lldb::eDynamicCanRunTarget));
-        m_dump_nsstring_measurement(frame_zero.FindVariable("str4", lldb::eDynamicCanRunTarget));
-        
-        m_dump_nsdate_measurement(frame_zero.FindVariable("me", lldb::eDynamicCanRunTarget));
-        m_dump_nsdate_measurement(frame_zero.FindVariable("cutie", lldb::eDynamicCanRunTarget));
-        m_dump_nsdate_measurement(frame_zero.FindVariable("mom", lldb::eDynamicCanRunTarget));
-        m_dump_nsdate_measurement(frame_zero.FindVariable("dad", lldb::eDynamicCanRunTarget));
-        m_dump_nsdate_measurement(frame_zero.FindVariable("today", lldb::eDynamicCanRunTarget));
-        
-        m_dump_nsbundle_measurement(frame_zero.FindVariable("bundles", lldb::eDynamicCanRunTarget));
-        m_dump_nsbundle_measurement(frame_zero.FindVariable("frameworks", lldb::eDynamicCanRunTarget));
-        
-        m_dump_nsset_measurement(frame_zero.FindVariable("nsset", lldb::eDynamicCanRunTarget));
-        m_dump_nsset_measurement(frame_zero.FindVariable("nsmutableset", lldb::eDynamicCanRunTarget));
-        
-        m_dump_std_vector_measurement(frame_zero.FindVariable("vector", lldb::eDynamicCanRunTarget));
-        m_dump_std_list_measurement(frame_zero.FindVariable("list", lldb::eDynamicCanRunTarget));
-        m_dump_std_map_measurement(frame_zero.FindVariable("map", lldb::eDynamicCanRunTarget));
-
-        auto sstr0 = frame_zero.FindVariable("sstr0", lldb::eDynamicCanRunTarget);
-        auto sstr1 = frame_zero.FindVariable("sstr1", lldb::eDynamicCanRunTarget);
-        auto sstr2 = frame_zero.FindVariable("sstr2", lldb::eDynamicCanRunTarget);
-        auto sstr3 = frame_zero.FindVariable("sstr3", lldb::eDynamicCanRunTarget);
-        auto sstr4 = frame_zero.FindVariable("sstr4", lldb::eDynamicCanRunTarget);
-        
-        m_dump_std_string_measurement.Start();
-        Xcode::FetchVariable(sstr0,0,false);
-        m_dump_std_string_measurement.Stop();
-        
-        m_dump_std_string_measurement.Start();
-        Xcode::FetchVariable(sstr1,0,false);
-        m_dump_std_string_measurement.Stop();
-
-        m_dump_std_string_measurement.Start();
-        Xcode::FetchVariable(sstr2,0,false);
-        m_dump_std_string_measurement.Stop();
-
-        m_dump_std_string_measurement.Start();
-        Xcode::FetchVariable(sstr3,0,false);
-        m_dump_std_string_measurement.Stop();
-
-        m_dump_std_string_measurement.Start();
-        Xcode::FetchVariable(sstr4,0,false);
-        m_dump_std_string_measurement.Stop();
-        
-    }
-    
-	virtual void
-	TestStep (int counter, ActionWanted &next_action)
-    {
-        switch (counter)
-        {
-            case 0:
-                m_target.BreakpointCreateByLocation("fmts_tester.mm", 78);
-                next_action.Continue();
-                break;
-            case 1:
-                DoTest ();
-                next_action.Continue();
-                break;
-            case 2:
-                DoTest ();
-                next_action.Continue();
-                break;
-            case 3:
-                DoTest ();
-                next_action.Continue();
-                break;
-            case 4:
-                DoTest ();
-                next_action.Continue();
-                break;
-            case 5:
-                DoTest ();
-                next_action.Continue();
-                break;
-            case 6:
-                DoTest ();
-                next_action.Continue();
-                break;
-            case 7:
-                DoTest ();
-                next_action.Continue();
-                break;
-            case 8:
-                DoTest ();
-                next_action.Continue();
-                break;
-            case 9:
-                DoTest ();
-                next_action.Continue();
-                break;
-            case 10:
-                DoTest ();
-                next_action.Continue();
-                break;
-            default:
-                next_action.Kill();
-                break;
-        }
-    }
-    
-    virtual void
-    WriteResults (Results &results)
-    {
-        m_dump_std_vector_measurement.WriteAverageAndStandardDeviation(results);
-        m_dump_std_list_measurement.WriteAverageAndStandardDeviation(results);
-        m_dump_std_map_measurement.WriteAverageAndStandardDeviation(results);
-        m_dump_std_string_measurement.WriteAverageAndStandardDeviation(results);
-        
-        m_dump_nsstring_measurement.WriteAverageAndStandardDeviation(results);
-        m_dump_nsarray_measurement.WriteAverageAndStandardDeviation(results);
-        m_dump_nsdictionary_measurement.WriteAverageAndStandardDeviation(results);
-        m_dump_nsset_measurement.WriteAverageAndStandardDeviation(results);
-        m_dump_nsbundle_measurement.WriteAverageAndStandardDeviation(results);
-        m_dump_nsdate_measurement.WriteAverageAndStandardDeviation(results);
-        results.Write(m_out_path.c_str());
+    // use this in manual mode
+    m_dump_std_string_measurement = CreateTimeMeasurement(
+        []() -> void {}, "std-string", "time to dump an std::string");
+
+    m_dump_nsstring_measurement = CreateTimeMeasurement(
+        [](SBValue value) -> void {
+          lldb_perf::Xcode::FetchVariable(value, 0, false);
+        },
+        "ns-string", "time to dump an NSString");
+
+    m_dump_nsarray_measurement = CreateTimeMeasurement(
+        [](SBValue value) -> void {
+          lldb_perf::Xcode::FetchVariable(value, 1, false);
+        },
+        "ns-array", "time to dump an NSArray");
+
+    m_dump_nsdictionary_measurement = CreateTimeMeasurement(
+        [](SBValue value) -> void {
+          lldb_perf::Xcode::FetchVariable(value, 1, false);
+        },
+        "ns-dictionary", "time to dump an NSDictionary");
+
+    m_dump_nsset_measurement = CreateTimeMeasurement(
+        [](SBValue value) -> void {
+          lldb_perf::Xcode::FetchVariable(value, 1, false);
+        },
+        "ns-set", "time to dump an NSSet");
+
+    m_dump_nsbundle_measurement = CreateTimeMeasurement(
+        [](SBValue value) -> void {
+          lldb_perf::Xcode::FetchVariable(value, 1, false);
+        },
+        "ns-bundle", "time to dump an NSBundle");
+
+    m_dump_nsdate_measurement = CreateTimeMeasurement(
+        [](SBValue value) -> void {
+          lldb_perf::Xcode::FetchVariable(value, 0, false);
+        },
+        "ns-date", "time to dump an NSDate");
+  }
+
+  virtual ~FormattersTest() {}
+
+  virtual bool Setup(int &argc, const char **&argv) {
+    m_app_path.assign(argv[1]);
+    m_out_path.assign(argv[2]);
+    m_target = m_debugger.CreateTarget(m_app_path.c_str());
+    m_target.BreakpointCreateByName("main");
+    SBLaunchInfo launch_info(argv);
+    return Launch(launch_info);
+  }
+
+  void DoTest() {
+    SBFrame frame_zero(m_thread.GetFrameAtIndex(0));
+
+    m_dump_nsarray_measurement(
+        frame_zero.FindVariable("nsarray", lldb::eDynamicCanRunTarget));
+    m_dump_nsarray_measurement(
+        frame_zero.FindVariable("nsmutablearray", lldb::eDynamicCanRunTarget));
+
+    m_dump_nsdictionary_measurement(
+        frame_zero.FindVariable("nsdictionary", lldb::eDynamicCanRunTarget));
+    m_dump_nsdictionary_measurement(frame_zero.FindVariable(
+        "nsmutabledictionary", lldb::eDynamicCanRunTarget));
+
+    m_dump_nsstring_measurement(
+        frame_zero.FindVariable("str0", lldb::eDynamicCanRunTarget));
+    m_dump_nsstring_measurement(
+        frame_zero.FindVariable("str1", lldb::eDynamicCanRunTarget));
+    m_dump_nsstring_measurement(
+        frame_zero.FindVariable("str2", lldb::eDynamicCanRunTarget));
+    m_dump_nsstring_measurement(
+        frame_zero.FindVariable("str3", lldb::eDynamicCanRunTarget));
+    m_dump_nsstring_measurement(
+        frame_zero.FindVariable("str4", lldb::eDynamicCanRunTarget));
+
+    m_dump_nsdate_measurement(
+        frame_zero.FindVariable("me", lldb::eDynamicCanRunTarget));
+    m_dump_nsdate_measurement(
+        frame_zero.FindVariable("cutie", lldb::eDynamicCanRunTarget));
+    m_dump_nsdate_measurement(
+        frame_zero.FindVariable("mom", lldb::eDynamicCanRunTarget));
+    m_dump_nsdate_measurement(
+        frame_zero.FindVariable("dad", lldb::eDynamicCanRunTarget));
+    m_dump_nsdate_measurement(
+        frame_zero.FindVariable("today", lldb::eDynamicCanRunTarget));
+
+    m_dump_nsbundle_measurement(
+        frame_zero.FindVariable("bundles", lldb::eDynamicCanRunTarget));
+    m_dump_nsbundle_measurement(
+        frame_zero.FindVariable("frameworks", lldb::eDynamicCanRunTarget));
+
+    m_dump_nsset_measurement(
+        frame_zero.FindVariable("nsset", lldb::eDynamicCanRunTarget));
+    m_dump_nsset_measurement(
+        frame_zero.FindVariable("nsmutableset", lldb::eDynamicCanRunTarget));
+
+    m_dump_std_vector_measurement(
+        frame_zero.FindVariable("vector", lldb::eDynamicCanRunTarget));
+    m_dump_std_list_measurement(
+        frame_zero.FindVariable("list", lldb::eDynamicCanRunTarget));
+    m_dump_std_map_measurement(
+        frame_zero.FindVariable("map", lldb::eDynamicCanRunTarget));
+
+    auto sstr0 = frame_zero.FindVariable("sstr0", lldb::eDynamicCanRunTarget);
+    auto sstr1 = frame_zero.FindVariable("sstr1", lldb::eDynamicCanRunTarget);
+    auto sstr2 = frame_zero.FindVariable("sstr2", lldb::eDynamicCanRunTarget);
+    auto sstr3 = frame_zero.FindVariable("sstr3", lldb::eDynamicCanRunTarget);
+    auto sstr4 = frame_zero.FindVariable("sstr4", lldb::eDynamicCanRunTarget);
+
+    m_dump_std_string_measurement.Start();
+    Xcode::FetchVariable(sstr0, 0, false);
+    m_dump_std_string_measurement.Stop();
+
+    m_dump_std_string_measurement.Start();
+    Xcode::FetchVariable(sstr1, 0, false);
+    m_dump_std_string_measurement.Stop();
+
+    m_dump_std_string_measurement.Start();
+    Xcode::FetchVariable(sstr2, 0, false);
+    m_dump_std_string_measurement.Stop();
+
+    m_dump_std_string_measurement.Start();
+    Xcode::FetchVariable(sstr3, 0, false);
+    m_dump_std_string_measurement.Stop();
+
+    m_dump_std_string_measurement.Start();
+    Xcode::FetchVariable(sstr4, 0, false);
+    m_dump_std_string_measurement.Stop();
+  }
+
+  virtual void TestStep(int counter, ActionWanted &next_action) {
+    switch (counter) {
+    case 0:
+      m_target.BreakpointCreateByLocation("fmts_tester.mm", 78);
+      next_action.Continue();
+      break;
+    case 1:
+      DoTest();
+      next_action.Continue();
+      break;
+    case 2:
+      DoTest();
+      next_action.Continue();
+      break;
+    case 3:
+      DoTest();
+      next_action.Continue();
+      break;
+    case 4:
+      DoTest();
+      next_action.Continue();
+      break;
+    case 5:
+      DoTest();
+      next_action.Continue();
+      break;
+    case 6:
+      DoTest();
+      next_action.Continue();
+      break;
+    case 7:
+      DoTest();
+      next_action.Continue();
+      break;
+    case 8:
+      DoTest();
+      next_action.Continue();
+      break;
+    case 9:
+      DoTest();
+      next_action.Continue();
+      break;
+    case 10:
+      DoTest();
+      next_action.Continue();
+      break;
+    default:
+      next_action.Kill();
+      break;
     }
-    
+  }
+
+  virtual void WriteResults(Results &results) {
+    m_dump_std_vector_measurement.WriteAverageAndStandardDeviation(results);
+    m_dump_std_list_measurement.WriteAverageAndStandardDeviation(results);
+    m_dump_std_map_measurement.WriteAverageAndStandardDeviation(results);
+    m_dump_std_string_measurement.WriteAverageAndStandardDeviation(results);
+
+    m_dump_nsstring_measurement.WriteAverageAndStandardDeviation(results);
+    m_dump_nsarray_measurement.WriteAverageAndStandardDeviation(results);
+    m_dump_nsdictionary_measurement.WriteAverageAndStandardDeviation(results);
+    m_dump_nsset_measurement.WriteAverageAndStandardDeviation(results);
+    m_dump_nsbundle_measurement.WriteAverageAndStandardDeviation(results);
+    m_dump_nsdate_measurement.WriteAverageAndStandardDeviation(results);
+    results.Write(m_out_path.c_str());
+  }
+
 private:
-    // C++ formatters
-    TimeMeasurement<std::function<void(SBValue)>> m_dump_std_vector_measurement;
-    TimeMeasurement<std::function<void(SBValue)>> m_dump_std_list_measurement;
-    TimeMeasurement<std::function<void(SBValue)>> m_dump_std_map_measurement;
-    TimeMeasurement<std::function<void()>> m_dump_std_string_measurement;
-
-    // Cocoa formatters
-    TimeMeasurement<std::function<void(SBValue)>> m_dump_nsstring_measurement;
-    TimeMeasurement<std::function<void(SBValue)>> m_dump_nsarray_measurement;
-    TimeMeasurement<std::function<void(SBValue)>> m_dump_nsdictionary_measurement;
-    TimeMeasurement<std::function<void(SBValue)>> m_dump_nsset_measurement;
-    TimeMeasurement<std::function<void(SBValue)>> m_dump_nsbundle_measurement;
-    TimeMeasurement<std::function<void(SBValue)>> m_dump_nsdate_measurement;
-
-    // useful files
-    std::string m_app_path;
-    std::string m_out_path;
+  // C++ formatters
+  TimeMeasurement<std::function<void(SBValue)>> m_dump_std_vector_measurement;
+  TimeMeasurement<std::function<void(SBValue)>> m_dump_std_list_measurement;
+  TimeMeasurement<std::function<void(SBValue)>> m_dump_std_map_measurement;
+  TimeMeasurement<std::function<void()>> m_dump_std_string_measurement;
+
+  // Cocoa formatters
+  TimeMeasurement<std::function<void(SBValue)>> m_dump_nsstring_measurement;
+  TimeMeasurement<std::function<void(SBValue)>> m_dump_nsarray_measurement;
+  TimeMeasurement<std::function<void(SBValue)>> m_dump_nsdictionary_measurement;
+  TimeMeasurement<std::function<void(SBValue)>> m_dump_nsset_measurement;
+  TimeMeasurement<std::function<void(SBValue)>> m_dump_nsbundle_measurement;
+  TimeMeasurement<std::function<void(SBValue)>> m_dump_nsdate_measurement;
+
+  // useful files
+  std::string m_app_path;
+  std::string m_out_path;
 };
 
 // argv[1] == path to app
 // argv[2] == path to result
-int main(int argc, const char * argv[])
-{
-    FormattersTest frmtest;
-    frmtest.SetVerbose(true);
-    TestCase::Run(frmtest,argc,argv);
-    return 0;
+int main(int argc, const char *argv[]) {
+  FormattersTest frmtest;
+  frmtest.SetVerbose(true);
+  TestCase::Run(frmtest, argc, argv);
+  return 0;
 }
-
diff --git a/lldb/tools/lldb-perf/darwin/sketch/sketch.cpp b/lldb/tools/lldb-perf/darwin/sketch/sketch.cpp
index 93e3916..ddcb445 100644
--- a/lldb/tools/lldb-perf/darwin/sketch/sketch.cpp
+++ b/lldb/tools/lldb-perf/darwin/sketch/sketch.cpp
@@ -9,152 +9,141 @@
 
 #include <CoreFoundation/CoreFoundation.h>
 
-#include "lldb-perf/lib/Timer.h"
-#include "lldb-perf/lib/Metric.h"
 #include "lldb-perf/lib/Measurement.h"
+#include "lldb-perf/lib/Metric.h"
 #include "lldb-perf/lib/TestCase.h"
+#include "lldb-perf/lib/Timer.h"
 #include "lldb-perf/lib/Xcode.h"
 
-#include <iostream>
-#include <unistd.h>
 #include <fstream>
 #include <getopt.h>
+#include <iostream>
+#include <unistd.h>
 
 using namespace lldb_perf;
 
 static struct option g_long_options[] = {
-    { "verbose",    no_argument,            NULL, 'v' },
-    { "sketch",     required_argument,      NULL, 'c' },
-    { "foobar",     required_argument,      NULL, 'f' },
-    { "out-file",   required_argument,      NULL, 'o' },
-    { NULL,         0,                      NULL,  0  }
-};
+    {"verbose", no_argument, NULL, 'v'},
+    {"sketch", required_argument, NULL, 'c'},
+    {"foobar", required_argument, NULL, 'f'},
+    {"out-file", required_argument, NULL, 'o'},
+    {NULL, 0, NULL, 0}};
 
-class SketchTest : public TestCase
-{
+class SketchTest : public TestCase {
 public:
-    SketchTest () :
-        m_fetch_frames_measurement ([this] () -> void
-            {
-                Xcode::FetchFrames (GetProcess(),false,false);
-            }, "fetch-frames", "time to dump backtrace for every frame in every thread"),
-        m_file_line_bp_measurement([this] (const char* file, uint32_t line) -> void
-            {
-                Xcode::CreateFileLineBreakpoint(GetTarget(), file, line);
-            }, "file-line-bkpt", "time to set a breakpoint given a file and line"),
-        m_fetch_modules_measurement ([this] () -> void
-            {
-                Xcode::FetchModules(GetTarget());
-            }, "fetch-modules", "time to get info for all modules in the process"),
-        m_fetch_vars_measurement([this] (int depth) -> void
-            {
-                SBProcess process (GetProcess());
-                auto threads_count = process.GetNumThreads();
-                for (size_t thread_num = 0; thread_num < threads_count; thread_num++)
-                {
-                    SBThread thread(process.GetThreadAtIndex(thread_num));
-                    SBFrame frame(thread.GetFrameAtIndex(0));
-                    Xcode::FetchVariables(frame,depth,GetVerbose());
-                }
-            }, "fetch-vars", "time to dump variables for the topmost frame in every thread"),
-        m_run_expr_measurement([this] (SBFrame frame, const char* expr) -> void
-            {
-                SBValue value(frame.EvaluateExpression(expr, lldb::eDynamicCanRunTarget));
-                Xcode::FetchVariable (value, 0, GetVerbose());
-            }, "run-expr", "time to evaluate an expression and display the result")
-    {
-        m_app_path.clear();
-        m_out_path.clear();
-        m_doc_path.clear();
-        m_print_help = false;
-    }
-    
-    virtual
-    ~SketchTest ()
-    {
+  SketchTest()
+      : m_fetch_frames_measurement(
+            [this]() -> void {
+              Xcode::FetchFrames(GetProcess(), false, false);
+            },
+            "fetch-frames",
+            "time to dump backtrace for every frame in every thread"),
+        m_file_line_bp_measurement(
+            [this](const char *file, uint32_t line) -> void {
+              Xcode::CreateFileLineBreakpoint(GetTarget(), file, line);
+            },
+            "file-line-bkpt", "time to set a breakpoint given a file and line"),
+        m_fetch_modules_measurement(
+            [this]() -> void { Xcode::FetchModules(GetTarget()); },
+            "fetch-modules", "time to get info for all modules in the process"),
+        m_fetch_vars_measurement(
+            [this](int depth) -> void {
+              SBProcess process(GetProcess());
+              auto threads_count = process.GetNumThreads();
+              for (size_t thread_num = 0; thread_num < threads_count;
+                   thread_num++) {
+                SBThread thread(process.GetThreadAtIndex(thread_num));
+                SBFrame frame(thread.GetFrameAtIndex(0));
+                Xcode::FetchVariables(frame, depth, GetVerbose());
+              }
+            },
+            "fetch-vars",
+            "time to dump variables for the topmost frame in every thread"),
+        m_run_expr_measurement(
+            [this](SBFrame frame, const char *expr) -> void {
+              SBValue value(
+                  frame.EvaluateExpression(expr, lldb::eDynamicCanRunTarget));
+              Xcode::FetchVariable(value, 0, GetVerbose());
+            },
+            "run-expr",
+            "time to evaluate an expression and display the result") {
+    m_app_path.clear();
+    m_out_path.clear();
+    m_doc_path.clear();
+    m_print_help = false;
+  }
+
+  virtual ~SketchTest() {}
+
+  virtual bool ParseOption(int short_option, const char *optarg) {
+    switch (short_option) {
+    case 0:
+      return false;
+
+    case -1:
+      return false;
+
+    case '?':
+    case 'h':
+      m_print_help = true;
+      break;
+
+    case 'v':
+      SetVerbose(true);
+      break;
+
+    case 'c': {
+      SBFileSpec file(optarg);
+      if (file.Exists())
+        SetExecutablePath(optarg);
+      else
+        fprintf(stderr, "error: file specified in --sketch (-c) option doesn't "
+                        "exist: '%s'\n",
+                optarg);
+    } break;
+
+    case 'f': {
+      SBFileSpec file(optarg);
+      if (file.Exists())
+        SetDocumentPath(optarg);
+      else
+        fprintf(stderr, "error: file specified in --foobar (-f) option doesn't "
+                        "exist: '%s'\n",
+                optarg);
+    } break;
+
+    case 'o':
+      SetResultFilePath(optarg);
+      break;
+
+    default:
+      m_print_help = true;
+      fprintf(stderr, "error: unrecognized option %c\n", short_option);
+      break;
     }
-    
-    virtual bool
-    ParseOption (int short_option, const char* optarg)
-    {
-        switch (short_option)
-        {
-            case 0:
-                return false;
-                
-            case -1:
-                return false;
-                
-            case '?':
-            case 'h':
-                m_print_help = true;
-                break;
-                
-            case 'v':
-                SetVerbose(true);
-                break;
-                
-            case 'c':
-            {
-                SBFileSpec file(optarg);
-                if (file.Exists())
-                    SetExecutablePath(optarg);
-                else
-                    fprintf(stderr, "error: file specified in --sketch (-c) option doesn't exist: '%s'\n", optarg);
-            }
-                break;
-                
-            case 'f':
-            {
-                SBFileSpec file(optarg);
-                if (file.Exists())
-                    SetDocumentPath(optarg);
-                else
-                    fprintf(stderr, "error: file specified in --foobar (-f) option doesn't exist: '%s'\n", optarg);
-            }
-                break;
-                
-            case 'o':
-                SetResultFilePath(optarg);
-                break;
-                
-            default:
-                m_print_help = true;
-                fprintf (stderr, "error: unrecognized option %c\n", short_option);
-                break;
-        }
-        return true;
+    return true;
+  }
+
+  virtual struct option *GetLongOptions() { return g_long_options; }
+
+  virtual bool Setup(int &argc, const char **&argv) {
+    TestCase::Setup(argc, argv);
+    bool error = false;
+
+    if (GetExecutablePath() == NULL) {
+      // --sketch is mandatory
+      error = true;
+      fprintf(stderr, "error: the '--sketch=PATH' option is mandatory\n");
     }
-    
-    virtual struct option*
-    GetLongOptions ()
-    {
-        return g_long_options;
+
+    if (GetDocumentPath() == NULL) {
+      // --foobar is mandatory
+      error = true;
+      fprintf(stderr, "error: the '--foobar=PATH' option is mandatory\n");
     }
-    
-    virtual bool
-	Setup (int& argc, const char**& argv)
-    {
-        TestCase::Setup(argc,argv);
-        bool error = false;
-        
-        if (GetExecutablePath() == NULL)
-        {
-            // --sketch is mandatory
-            error = true;
-            fprintf (stderr, "error: the '--sketch=PATH' option is mandatory\n");
-        }
-        
-        if (GetDocumentPath() == NULL)
-        {
-            // --foobar is mandatory
-            error = true;
-            fprintf (stderr, "error: the '--foobar=PATH' option is mandatory\n");
-        }
-        
-        if (error || GetPrintHelp())
-        {
-            puts(R"(
+
+    if (error || GetPrintHelp()) {
+      puts(R"(
                  NAME
                  lldb_perf_sketch -- a tool that measures LLDB peformance while debugging sketch.
                  
@@ -165,216 +154,177 @@ public:
                  Runs a set of static timing and memory tasks against sketch and outputs results
                  to a plist file.
                  )");
-        }
-        
-        if (error)
-        {
-            exit(1);
-        }
-        lldb::SBLaunchInfo launch_info = GetLaunchInfo();
-        m_target = m_debugger.CreateTarget(m_app_path.c_str());
-        m_file_line_bp_measurement("SKTDocument.m",245);
-        m_file_line_bp_measurement("SKTDocument.m",283);
-        m_file_line_bp_measurement("SKTText.m",326);
-        return Launch (launch_info);
-    }
-    
-    lldb::SBLaunchInfo
-    GetLaunchInfo ()
-    {
-        const char* file_arg = m_doc_path.c_str();
-        const char* persist_arg = "-ApplePersistenceIgnoreState";
-        const char* persist_skip = "YES";
-        const char* empty = nullptr;
-        const char* args[] = {file_arg,persist_arg,persist_skip,empty};
-        return SBLaunchInfo(args);
-    }
-    
-    void
-    DoTest ()
-    {
-        m_fetch_frames_measurement();
-        m_fetch_modules_measurement();
-        m_fetch_vars_measurement(1);
-    }
-    
-	virtual void
-	TestStep (int counter, ActionWanted &next_action)
-    {
-        static int launch = 1;
-        switch (counter % 10)
-        {
-        case 0:
-            {
-                DoTest ();
-                if (counter == 0)
-                    m_file_line_bp_measurement("SKTDocument.m",254);
-                next_action.Continue();
-            }
-            break;
-                
-        case 1:
-            {
-                DoTest ();
-                m_run_expr_measurement(m_thread.GetFrameAtIndex(0),"properties");
-                m_run_expr_measurement(m_thread.GetFrameAtIndex(0),"[properties description]");
-                m_run_expr_measurement(m_thread.GetFrameAtIndex(0),"typeName");
-                m_run_expr_measurement(m_thread.GetFrameAtIndex(0),"data");
-                m_run_expr_measurement(m_thread.GetFrameAtIndex(0),"[data description]");
-                next_action.Continue();
-            }
-            break;
-
-        case 2:
-            {
-                DoTest ();
-                next_action.Continue();
-            }
-            break;
-
-        case 3:
-            {
-                DoTest ();
-                next_action.StepOver(m_thread);
-            }
-            break;
-
-        case 4:
-            {
-                DoTest ();
-                m_run_expr_measurement(m_thread.GetFrameAtIndex(0),"layoutManager");
-                m_run_expr_measurement(m_thread.GetFrameAtIndex(0),"contents");
-                next_action.StepOver(m_thread);
-            }
-            break;
-        
-        case 5:
-            {
-                DoTest ();
-                next_action.StepOver(m_thread);
-            }
-            break;
-
-        case 6:
-            {
-                DoTest ();
-                next_action.StepOver(m_thread);
-            }
-            break;
-
-        case 7:
-            {
-                DoTest ();
-                m_run_expr_measurement(m_thread.GetFrameAtIndex(0),"@\"an NSString\"");
-                m_run_expr_measurement(m_thread.GetFrameAtIndex(0),"[(id)@\"an NSString\" description]");
-                m_run_expr_measurement(m_thread.GetFrameAtIndex(0),"@[@1,@2,@3]");
-                next_action.StepOut(m_thread);
-            }
-            break;
-
-        case 8:
-            {
-                DoTest ();
-                m_run_expr_measurement(m_thread.GetFrameAtIndex(0),"[graphics description]");
-                m_run_expr_measurement(m_thread.GetFrameAtIndex(0),"[selectionIndexes description]");
-                m_run_expr_measurement(m_thread.GetFrameAtIndex(0),"(BOOL)NSIntersectsRect(rect, graphicDrawingBounds)");
-            }
-            next_action.CallNext();
-            break;
-        case 9:
-            if (++launch < 10)
-                next_action.Relaunch(GetLaunchInfo());
-            else
-                next_action.Kill();
-            break;
-        
-                
-        default:
-            {
-                next_action.Kill();
-            }
-            break;
-        }
-    }
-    
-    virtual void
-    WriteResults (Results &results)
-    {
-        m_fetch_frames_measurement.WriteAverageAndStandardDeviation(results);
-        m_file_line_bp_measurement.WriteAverageAndStandardDeviation(results);
-        m_fetch_modules_measurement.WriteAverageAndStandardDeviation(results);
-        m_fetch_vars_measurement.WriteAverageAndStandardDeviation(results);
-        m_run_expr_measurement.WriteAverageAndStandardDeviation(results);
-        results.Write(GetResultFilePath());
-    }
-    
-    void
-    SetExecutablePath (const char* str)
-    {
-        if (str)
-            m_app_path.assign(str);
-    }
-    
-    const char*
-    GetExecutablePath ()
-    {
-        if (m_app_path.empty())
-            return NULL;
-        return m_app_path.c_str();
-    }
-    
-    void
-    SetDocumentPath (const char* str)
-    {
-        if (str)
-            m_doc_path.assign(str);
-    }
-    
-    const char*
-    GetDocumentPath ()
-    {
-        if (m_doc_path.empty())
-            return NULL;
-        return m_doc_path.c_str();
     }
 
-    
-    void
-    SetResultFilePath (const char* str)
-    {
-        if (str)
-            m_out_path.assign(str);
+    if (error) {
+      exit(1);
     }
-    
-    const char*
-    GetResultFilePath ()
-    {
-        if (m_out_path.empty())
-            return "/dev/stdout";
-        return m_out_path.c_str();
+    lldb::SBLaunchInfo launch_info = GetLaunchInfo();
+    m_target = m_debugger.CreateTarget(m_app_path.c_str());
+    m_file_line_bp_measurement("SKTDocument.m", 245);
+    m_file_line_bp_measurement("SKTDocument.m", 283);
+    m_file_line_bp_measurement("SKTText.m", 326);
+    return Launch(launch_info);
+  }
+
+  lldb::SBLaunchInfo GetLaunchInfo() {
+    const char *file_arg = m_doc_path.c_str();
+    const char *persist_arg = "-ApplePersistenceIgnoreState";
+    const char *persist_skip = "YES";
+    const char *empty = nullptr;
+    const char *args[] = {file_arg, persist_arg, persist_skip, empty};
+    return SBLaunchInfo(args);
+  }
+
+  void DoTest() {
+    m_fetch_frames_measurement();
+    m_fetch_modules_measurement();
+    m_fetch_vars_measurement(1);
+  }
+
+  virtual void TestStep(int counter, ActionWanted &next_action) {
+    static int launch = 1;
+    switch (counter % 10) {
+    case 0: {
+      DoTest();
+      if (counter == 0)
+        m_file_line_bp_measurement("SKTDocument.m", 254);
+      next_action.Continue();
+    } break;
+
+    case 1: {
+      DoTest();
+      m_run_expr_measurement(m_thread.GetFrameAtIndex(0), "properties");
+      m_run_expr_measurement(m_thread.GetFrameAtIndex(0),
+                             "[properties description]");
+      m_run_expr_measurement(m_thread.GetFrameAtIndex(0), "typeName");
+      m_run_expr_measurement(m_thread.GetFrameAtIndex(0), "data");
+      m_run_expr_measurement(m_thread.GetFrameAtIndex(0), "[data description]");
+      next_action.Continue();
+    } break;
+
+    case 2: {
+      DoTest();
+      next_action.Continue();
+    } break;
+
+    case 3: {
+      DoTest();
+      next_action.StepOver(m_thread);
+    } break;
+
+    case 4: {
+      DoTest();
+      m_run_expr_measurement(m_thread.GetFrameAtIndex(0), "layoutManager");
+      m_run_expr_measurement(m_thread.GetFrameAtIndex(0), "contents");
+      next_action.StepOver(m_thread);
+    } break;
+
+    case 5: {
+      DoTest();
+      next_action.StepOver(m_thread);
+    } break;
+
+    case 6: {
+      DoTest();
+      next_action.StepOver(m_thread);
+    } break;
+
+    case 7: {
+      DoTest();
+      m_run_expr_measurement(m_thread.GetFrameAtIndex(0), "@\"an NSString\"");
+      m_run_expr_measurement(m_thread.GetFrameAtIndex(0),
+                             "[(id)@\"an NSString\" description]");
+      m_run_expr_measurement(m_thread.GetFrameAtIndex(0), "@[@1,@2,@3]");
+      next_action.StepOut(m_thread);
+    } break;
+
+    case 8: {
+      DoTest();
+      m_run_expr_measurement(m_thread.GetFrameAtIndex(0),
+                             "[graphics description]");
+      m_run_expr_measurement(m_thread.GetFrameAtIndex(0),
+                             "[selectionIndexes description]");
+      m_run_expr_measurement(
+          m_thread.GetFrameAtIndex(0),
+          "(BOOL)NSIntersectsRect(rect, graphicDrawingBounds)");
     }
-    
-    bool
-    GetPrintHelp ()
-    {
-        return m_print_help;
+      next_action.CallNext();
+      break;
+    case 9:
+      if (++launch < 10)
+        next_action.Relaunch(GetLaunchInfo());
+      else
+        next_action.Kill();
+      break;
+
+    default: { next_action.Kill(); } break;
     }
-    
+  }
+
+  virtual void WriteResults(Results &results) {
+    m_fetch_frames_measurement.WriteAverageAndStandardDeviation(results);
+    m_file_line_bp_measurement.WriteAverageAndStandardDeviation(results);
+    m_fetch_modules_measurement.WriteAverageAndStandardDeviation(results);
+    m_fetch_vars_measurement.WriteAverageAndStandardDeviation(results);
+    m_run_expr_measurement.WriteAverageAndStandardDeviation(results);
+    results.Write(GetResultFilePath());
+  }
+
+  void SetExecutablePath(const char *str) {
+    if (str)
+      m_app_path.assign(str);
+  }
+
+  const char *GetExecutablePath() {
+    if (m_app_path.empty())
+      return NULL;
+    return m_app_path.c_str();
+  }
+
+  void SetDocumentPath(const char *str) {
+    if (str)
+      m_doc_path.assign(str);
+  }
+
+  const char *GetDocumentPath() {
+    if (m_doc_path.empty())
+      return NULL;
+    return m_doc_path.c_str();
+  }
+
+  void SetResultFilePath(const char *str) {
+    if (str)
+      m_out_path.assign(str);
+  }
+
+  const char *GetResultFilePath() {
+    if (m_out_path.empty())
+      return "/dev/stdout";
+    return m_out_path.c_str();
+  }
+
+  bool GetPrintHelp() { return m_print_help; }
+
 private:
-    Measurement<lldb_perf::TimeGauge, std::function<void()>> m_fetch_frames_measurement;
-    Measurement<lldb_perf::TimeGauge, std::function<void(const char*, uint32_t)>> m_file_line_bp_measurement;
-    Measurement<lldb_perf::TimeGauge, std::function<void()>> m_fetch_modules_measurement;
-    Measurement<lldb_perf::TimeGauge, std::function<void(int)>> m_fetch_vars_measurement;
-    Measurement<lldb_perf::TimeGauge, std::function<void(SBFrame, const char*)>> m_run_expr_measurement;
-    
-    std::string m_app_path;
-    std::string m_doc_path;
-    std::string m_out_path;
-    bool m_print_help;
+  Measurement<lldb_perf::TimeGauge, std::function<void()>>
+      m_fetch_frames_measurement;
+  Measurement<lldb_perf::TimeGauge, std::function<void(const char *, uint32_t)>>
+      m_file_line_bp_measurement;
+  Measurement<lldb_perf::TimeGauge, std::function<void()>>
+      m_fetch_modules_measurement;
+  Measurement<lldb_perf::TimeGauge, std::function<void(int)>>
+      m_fetch_vars_measurement;
+  Measurement<lldb_perf::TimeGauge, std::function<void(SBFrame, const char *)>>
+      m_run_expr_measurement;
+
+  std::string m_app_path;
+  std::string m_doc_path;
+  std::string m_out_path;
+  bool m_print_help;
 };
 
-int main(int argc, const char * argv[])
-{
-    SketchTest test;
-    return TestCase::Run(test, argc, argv);
+int main(int argc, const char *argv[]) {
+  SketchTest test;
+  return TestCase::Run(test, argc, argv);
 }
diff --git a/lldb/tools/lldb-perf/lib/Gauge.cpp b/lldb/tools/lldb-perf/lib/Gauge.cpp
index 4c4593b..8c3333da 100644
--- a/lldb/tools/lldb-perf/lib/Gauge.cpp
+++ b/lldb/tools/lldb-perf/lib/Gauge.cpp
@@ -11,43 +11,40 @@
 #include "lldb/lldb-forward.h"
 
 template <>
-lldb_perf::Results::ResultSP
-lldb_perf::GetResult (const char *description, double value)
-{
-    if (description && description[0])
-    {
-        std::unique_ptr<Results::Dictionary> value_dict_ap (new Results::Dictionary ());
-        value_dict_ap->AddString("description", NULL, description);
-        value_dict_ap->AddDouble("value", NULL, value);
-        return Results::ResultSP (value_dict_ap.release());
-    }
-    return Results::ResultSP (new Results::Double (NULL, NULL, value));
+lldb_perf::Results::ResultSP lldb_perf::GetResult(const char *description,
+                                                  double value) {
+  if (description && description[0]) {
+    std::unique_ptr<Results::Dictionary> value_dict_ap(
+        new Results::Dictionary());
+    value_dict_ap->AddString("description", NULL, description);
+    value_dict_ap->AddDouble("value", NULL, value);
+    return Results::ResultSP(value_dict_ap.release());
+  }
+  return Results::ResultSP(new Results::Double(NULL, NULL, value));
 }
 
 template <>
-lldb_perf::Results::ResultSP
-lldb_perf::GetResult (const char *description, uint64_t value)
-{
-    if (description && description[0])
-    {
-        std::unique_ptr<Results::Dictionary> value_dict_ap (new Results::Dictionary ());
-        value_dict_ap->AddString("description", NULL, description);
-        value_dict_ap->AddUnsigned("value", NULL, value);
-        return Results::ResultSP (value_dict_ap.release());
-    }
-    return Results::ResultSP (new Results::Unsigned (NULL, NULL, value));
+lldb_perf::Results::ResultSP lldb_perf::GetResult(const char *description,
+                                                  uint64_t value) {
+  if (description && description[0]) {
+    std::unique_ptr<Results::Dictionary> value_dict_ap(
+        new Results::Dictionary());
+    value_dict_ap->AddString("description", NULL, description);
+    value_dict_ap->AddUnsigned("value", NULL, value);
+    return Results::ResultSP(value_dict_ap.release());
+  }
+  return Results::ResultSP(new Results::Unsigned(NULL, NULL, value));
 }
 
 template <>
-lldb_perf::Results::ResultSP
-lldb_perf::GetResult (const char *description, std::string value)
-{
-    if (description && description[0])
-    {
-        std::unique_ptr<Results::Dictionary> value_dict_ap (new Results::Dictionary ());
-        value_dict_ap->AddString("description", NULL, description);
-        value_dict_ap->AddString("value", NULL, value.c_str());
-        return Results::ResultSP (value_dict_ap.release());
-    }
-    return Results::ResultSP (new Results::String (NULL, NULL, value.c_str()));
+lldb_perf::Results::ResultSP lldb_perf::GetResult(const char *description,
+                                                  std::string value) {
+  if (description && description[0]) {
+    std::unique_ptr<Results::Dictionary> value_dict_ap(
+        new Results::Dictionary());
+    value_dict_ap->AddString("description", NULL, description);
+    value_dict_ap->AddString("value", NULL, value.c_str());
+    return Results::ResultSP(value_dict_ap.release());
+  }
+  return Results::ResultSP(new Results::String(NULL, NULL, value.c_str()));
 }
diff --git a/lldb/tools/lldb-perf/lib/Gauge.h b/lldb/tools/lldb-perf/lib/Gauge.h
index fc5c444..1fecbdb 100644
--- a/lldb/tools/lldb-perf/lib/Gauge.h
+++ b/lldb/tools/lldb-perf/lib/Gauge.h
@@ -17,48 +17,35 @@
 
 namespace lldb_perf {
 
-template <class T>
-class Gauge
-{
+template <class T> class Gauge {
 public:
-    typedef T ValueType;
-
-    Gauge ()
-    {}
-    
-    virtual
-    ~Gauge ()
-    {}
-    
-    virtual void
-    Start () = 0;
-    
-    virtual ValueType
-    Stop () = 0;
-
-    virtual ValueType
-    GetStartValue () const = 0;
-
-    virtual ValueType
-    GetStopValue () const = 0;
-
-    virtual ValueType
-    GetDeltaValue () const = 0;
+  typedef T ValueType;
+
+  Gauge() {}
+
+  virtual ~Gauge() {}
+
+  virtual void Start() = 0;
+
+  virtual ValueType Stop() = 0;
 
+  virtual ValueType GetStartValue() const = 0;
+
+  virtual ValueType GetStopValue() const = 0;
+
+  virtual ValueType GetDeltaValue() const = 0;
 };
 
 template <class T>
-Results::ResultSP GetResult (const char *description, T value);
+Results::ResultSP GetResult(const char *description, T value);
 
-template <>
-Results::ResultSP GetResult (const char *description, double value);
+template <> Results::ResultSP GetResult(const char *description, double value);
 
 template <>
-Results::ResultSP GetResult (const char *description, uint64_t value);
+Results::ResultSP GetResult(const char *description, uint64_t value);
 
 template <>
-Results::ResultSP GetResult (const char *description, std::string value);
-
+Results::ResultSP GetResult(const char *description, std::string value);
 }
 
 #endif
diff --git a/lldb/tools/lldb-perf/lib/Measurement.h b/lldb/tools/lldb-perf/lib/Measurement.h
index 877e618..1795211 100644
--- a/lldb/tools/lldb-perf/lib/Measurement.h
+++ b/lldb/tools/lldb-perf/lib/Measurement.h
@@ -11,207 +11,148 @@
 #define __PerfTestDriver__Measurement__
 
 #include "Gauge.h"
-#include "Timer.h"
-#include "Metric.h"
 #include "MemoryGauge.h"
+#include "Metric.h"
+#include "Timer.h"
 
-namespace lldb_perf
-{
-template <typename GaugeType, typename Callable>
-class Measurement
-{
+namespace lldb_perf {
+template <typename GaugeType, typename Callable> class Measurement {
 public:
-    Measurement () :
-        m_gauge (),
-        m_callable (),
-        m_metric ()
-    {
-    }
-    
-    Measurement (Callable callable, const char* name, const char* desc)  :
-        m_gauge (),
-        m_callable (callable),
-        m_metric (Metric<typename GaugeType::ValueType>(name, desc))
-    {
-    }
+  Measurement() : m_gauge(), m_callable(), m_metric() {}
 
-    Measurement (const char* name, const char* desc)  :
-        m_gauge (),
-        m_callable (),
-        m_metric (Metric<typename GaugeType::ValueType>(name, desc))
-    {
-    }
+  Measurement(Callable callable, const char *name, const char *desc)
+      : m_gauge(), m_callable(callable),
+        m_metric(Metric<typename GaugeType::ValueType>(name, desc)) {}
 
-    template <typename GaugeType_Rhs, typename Callable_Rhs>
-    Measurement (const Measurement<GaugeType_Rhs, Callable_Rhs>& rhs) :
-        m_gauge(rhs.GetGauge()),
-        m_callable(rhs.GetCallable()),
-        m_metric(rhs.GetMetric())
-    {
-    }
+  Measurement(const char *name, const char *desc)
+      : m_gauge(), m_callable(),
+        m_metric(Metric<typename GaugeType::ValueType>(name, desc)) {}
 
-    template <typename... Args>
-    void
-    operator () (Args... args)
-    {
-        m_gauge.Start();
-        m_callable(args...);
-        m_metric.Append (m_gauge.Stop());
-    }
-    
-    virtual const Callable&
-    GetCallable () const
-    {
-        return m_callable;
-    }
-    
-    virtual const GaugeType&
-    GetGauge () const
-    {
-        return m_gauge;
-    }
-    
-    virtual const Metric<typename GaugeType::ValueType>&
-    GetMetric () const
-    {
-        return m_metric;
-    }
-    
-    void
-    Start ()
-    {
-        m_gauge.Start();
-    }
-    
-    typename GaugeType::ValueType
-    Stop ()
-    {
-        auto value = m_gauge.Stop();
-        m_metric.Append(value);
-        return value;
-    }
+  template <typename GaugeType_Rhs, typename Callable_Rhs>
+  Measurement(const Measurement<GaugeType_Rhs, Callable_Rhs> &rhs)
+      : m_gauge(rhs.GetGauge()), m_callable(rhs.GetCallable()),
+        m_metric(rhs.GetMetric()) {}
 
-    void
-    WriteStartValue (Results &results)
-    {
-        auto metric = GetMetric ();
-        results.GetDictionary().Add(metric.GetName(), metric.GetDescription(), lldb_perf::GetResult<typename GaugeType::ValueType> (NULL, metric.GetStartValue()));
-    }
-    
-    void
-    WriteStopValue (Results &results)
-    {
-        auto metric = GetMetric ();
-        results.GetDictionary().Add(metric.GetName(), metric.GetDescription(), lldb_perf::GetResult<typename GaugeType::ValueType> (NULL, metric.GetStopValue()));
-    }
+  template <typename... Args> void operator()(Args... args) {
+    m_gauge.Start();
+    m_callable(args...);
+    m_metric.Append(m_gauge.Stop());
+  }
 
-    void
-    WriteAverageValue (Results &results)
-    {
-        auto metric = GetMetric ();
-        results.GetDictionary().Add(metric.GetName(), metric.GetDescription(), lldb_perf::GetResult<typename GaugeType::ValueType> (NULL, metric.GetAverage()));
-    }
-    
-    void
-    WriteAverageAndStandardDeviation (Results &results)
-    {
-        auto metric = GetMetric ();
-        auto dictionary = (Results::Dictionary*)results.GetDictionary().Add(metric.GetName(), metric.GetDescription(), lldb_perf::GetResult<typename GaugeType::ValueType> (NULL, metric.GetAverage())).get();
-        if (dictionary)
-        {
-            dictionary->Add("stddev", NULL, lldb_perf::GetResult<typename GaugeType::ValueType> (NULL, metric.GetStandardDeviation()));
-        }
-    }
-    
-    void
-    WriteStandardDeviation (Results &results)
-    {
-        auto metric = GetMetric ();
-        results.GetDictionary().Add(metric.GetName(), metric.GetDescription(), lldb_perf::GetResult<typename GaugeType::ValueType> (NULL, metric.GetStandardDeviation()));
-    }
+  virtual const Callable &GetCallable() const { return m_callable; }
+
+  virtual const GaugeType &GetGauge() const { return m_gauge; }
+
+  virtual const Metric<typename GaugeType::ValueType> &GetMetric() const {
+    return m_metric;
+  }
+
+  void Start() { m_gauge.Start(); }
+
+  typename GaugeType::ValueType Stop() {
+    auto value = m_gauge.Stop();
+    m_metric.Append(value);
+    return value;
+  }
+
+  void WriteStartValue(Results &results) {
+    auto metric = GetMetric();
+    results.GetDictionary().Add(
+        metric.GetName(), metric.GetDescription(),
+        lldb_perf::GetResult<typename GaugeType::ValueType>(
+            NULL, metric.GetStartValue()));
+  }
+
+  void WriteStopValue(Results &results) {
+    auto metric = GetMetric();
+    results.GetDictionary().Add(
+        metric.GetName(), metric.GetDescription(),
+        lldb_perf::GetResult<typename GaugeType::ValueType>(
+            NULL, metric.GetStopValue()));
+  }
+
+  void WriteAverageValue(Results &results) {
+    auto metric = GetMetric();
+    results.GetDictionary().Add(
+        metric.GetName(), metric.GetDescription(),
+        lldb_perf::GetResult<typename GaugeType::ValueType>(
+            NULL, metric.GetAverage()));
+  }
+
+  void WriteAverageAndStandardDeviation(Results &results) {
+    auto metric = GetMetric();
+    auto dictionary =
+        (Results::Dictionary *)results.GetDictionary()
+            .Add(metric.GetName(), metric.GetDescription(),
+                 lldb_perf::GetResult<typename GaugeType::ValueType>(
+                     NULL, metric.GetAverage()))
+            .get();
+    if (dictionary) {
+      dictionary->Add("stddev", NULL,
+                      lldb_perf::GetResult<typename GaugeType::ValueType>(
+                          NULL, metric.GetStandardDeviation()));
+    }
+  }
+
+  void WriteStandardDeviation(Results &results) {
+    auto metric = GetMetric();
+    results.GetDictionary().Add(
+        metric.GetName(), metric.GetDescription(),
+        lldb_perf::GetResult<typename GaugeType::ValueType>(
+            NULL, metric.GetStandardDeviation()));
+  }
 
 protected:
-    GaugeType m_gauge;
-    Callable m_callable;
-    Metric<typename GaugeType::ValueType> m_metric;
+  GaugeType m_gauge;
+  Callable m_callable;
+  Metric<typename GaugeType::ValueType> m_metric;
 };
-    
+
 template <typename Callable>
-class TimeMeasurement : public Measurement<TimeGauge,Callable>
-{
+class TimeMeasurement : public Measurement<TimeGauge, Callable> {
 public:
-    TimeMeasurement () :
-        Measurement<TimeGauge,Callable> ()
-    {
-    }
-    
-    TimeMeasurement (Callable callable,
-                     const char* name = NULL,
-                     const char* descr = NULL) :
-        Measurement<TimeGauge,Callable> (callable, name, descr)
-    {
-    }
-    
-    template <typename Callable_Rhs>
-    TimeMeasurement (const TimeMeasurement<Callable_Rhs>& rhs) :
-        Measurement<TimeGauge,Callable>(rhs)
-    {
-    }
-    
-    template <typename GaugeType_Rhs, typename Callable_Rhs>
-    TimeMeasurement (const Measurement<GaugeType_Rhs, Callable_Rhs>& rhs) :
-        Measurement<GaugeType_Rhs,Callable_Rhs>(rhs)
-    {
-    }
-    
-    template <typename... Args>
-    void
-    operator () (Args... args)
-    {
-        Measurement<TimeGauge,Callable>::operator()(args...);
-    }
+  TimeMeasurement() : Measurement<TimeGauge, Callable>() {}
+
+  TimeMeasurement(Callable callable, const char *name = NULL,
+                  const char *descr = NULL)
+      : Measurement<TimeGauge, Callable>(callable, name, descr) {}
+
+  template <typename Callable_Rhs>
+  TimeMeasurement(const TimeMeasurement<Callable_Rhs> &rhs)
+      : Measurement<TimeGauge, Callable>(rhs) {}
+
+  template <typename GaugeType_Rhs, typename Callable_Rhs>
+  TimeMeasurement(const Measurement<GaugeType_Rhs, Callable_Rhs> &rhs)
+      : Measurement<GaugeType_Rhs, Callable_Rhs>(rhs) {}
+
+  template <typename... Args> void operator()(Args... args) {
+    Measurement<TimeGauge, Callable>::operator()(args...);
+  }
 };
 
 template <typename Callable>
-class MemoryMeasurement : public Measurement<MemoryGauge,Callable>
-{
+class MemoryMeasurement : public Measurement<MemoryGauge, Callable> {
 public:
-    MemoryMeasurement () : Measurement<MemoryGauge,Callable> ()
-    {
-    }
-    
-    MemoryMeasurement (Callable callable,
-                       const char* name,
-                       const char* descr) :
-        Measurement<MemoryGauge,Callable> (callable, name, descr)
-    {
-    }
+  MemoryMeasurement() : Measurement<MemoryGauge, Callable>() {}
 
-    MemoryMeasurement (const char* name, const char* descr) :
-        Measurement<MemoryGauge,Callable> (name, descr)
-    {
-    }
+  MemoryMeasurement(Callable callable, const char *name, const char *descr)
+      : Measurement<MemoryGauge, Callable>(callable, name, descr) {}
 
-    template <typename Callable_Rhs>
-    MemoryMeasurement (const MemoryMeasurement<Callable_Rhs>& rhs) :
-        Measurement<MemoryGauge,Callable>(rhs)
-    {
-    }
-    
-    template <typename GaugeType_Rhs, typename Callable_Rhs>
-    MemoryMeasurement (const Measurement<GaugeType_Rhs, Callable_Rhs>& rhs) :
-        Measurement<GaugeType_Rhs,Callable_Rhs>(rhs)
-    {
-    }
-    
-    template <typename... Args>
-    void
-    operator () (Args... args)
-    {
-        Measurement<MemoryGauge,Callable>::operator()(args...);
-    }
+  MemoryMeasurement(const char *name, const char *descr)
+      : Measurement<MemoryGauge, Callable>(name, descr) {}
+
+  template <typename Callable_Rhs>
+  MemoryMeasurement(const MemoryMeasurement<Callable_Rhs> &rhs)
+      : Measurement<MemoryGauge, Callable>(rhs) {}
+
+  template <typename GaugeType_Rhs, typename Callable_Rhs>
+  MemoryMeasurement(const Measurement<GaugeType_Rhs, Callable_Rhs> &rhs)
+      : Measurement<GaugeType_Rhs, Callable_Rhs>(rhs) {}
+
+  template <typename... Args> void operator()(Args... args) {
+    Measurement<MemoryGauge, Callable>::operator()(args...);
+  }
 };
-    
 }
 
 #endif /* defined(__PerfTestDriver__Measurement__) */
diff --git a/lldb/tools/lldb-perf/lib/MemoryGauge.cpp b/lldb/tools/lldb-perf/lib/MemoryGauge.cpp
index 2a46453..2727f9b 100644
--- a/lldb/tools/lldb-perf/lib/MemoryGauge.cpp
+++ b/lldb/tools/lldb-perf/lib/MemoryGauge.cpp
@@ -12,154 +12,122 @@
 #include <assert.h>
 #include <cmath>
 #include <mach/mach.h>
-#include <mach/task.h>
 #include <mach/mach_traps.h>
+#include <mach/task.h>
 
 using namespace lldb_perf;
 
-MemoryStats::MemoryStats (mach_vm_size_t virtual_size,
-                          mach_vm_size_t resident_size,
-                          mach_vm_size_t max_resident_size) :
-    m_virtual_size (virtual_size),
-    m_resident_size (resident_size),
-    m_max_resident_size (max_resident_size)
-{
-}
-
-MemoryStats::MemoryStats (const MemoryStats& rhs) :
-    m_virtual_size (rhs.m_virtual_size),
-    m_resident_size (rhs.m_resident_size),
-    m_max_resident_size (rhs.m_max_resident_size)
-{
-}
+MemoryStats::MemoryStats(mach_vm_size_t virtual_size,
+                         mach_vm_size_t resident_size,
+                         mach_vm_size_t max_resident_size)
+    : m_virtual_size(virtual_size), m_resident_size(resident_size),
+      m_max_resident_size(max_resident_size) {}
 
+MemoryStats::MemoryStats(const MemoryStats &rhs)
+    : m_virtual_size(rhs.m_virtual_size), m_resident_size(rhs.m_resident_size),
+      m_max_resident_size(rhs.m_max_resident_size) {}
 
-MemoryStats&
-MemoryStats::operator = (const MemoryStats& rhs)
-{
-    if (this != &rhs)
-    {
-        m_virtual_size = rhs.m_virtual_size;
-        m_resident_size = rhs.m_resident_size;
-        m_max_resident_size = rhs.m_max_resident_size;
-    }
-    return *this;
+MemoryStats &MemoryStats::operator=(const MemoryStats &rhs) {
+  if (this != &rhs) {
+    m_virtual_size = rhs.m_virtual_size;
+    m_resident_size = rhs.m_resident_size;
+    m_max_resident_size = rhs.m_max_resident_size;
+  }
+  return *this;
 }
 
-MemoryStats&
-MemoryStats::operator += (const MemoryStats& rhs)
-{
-    m_virtual_size += rhs.m_virtual_size;
-    m_resident_size += rhs.m_resident_size;
-    m_max_resident_size += rhs.m_max_resident_size;
-    return *this;
+MemoryStats &MemoryStats::operator+=(const MemoryStats &rhs) {
+  m_virtual_size += rhs.m_virtual_size;
+  m_resident_size += rhs.m_resident_size;
+  m_max_resident_size += rhs.m_max_resident_size;
+  return *this;
 }
 
-MemoryStats
-MemoryStats::operator - (const MemoryStats& rhs)
-{
-    return MemoryStats(m_virtual_size - rhs.m_virtual_size,
-                       m_resident_size - rhs.m_resident_size,
-                       m_max_resident_size - rhs.m_max_resident_size);
+MemoryStats MemoryStats::operator-(const MemoryStats &rhs) {
+  return MemoryStats(m_virtual_size - rhs.m_virtual_size,
+                     m_resident_size - rhs.m_resident_size,
+                     m_max_resident_size - rhs.m_max_resident_size);
 }
 
-MemoryStats
-MemoryStats::operator + (const MemoryStats& rhs)
-{
-    return MemoryStats(m_virtual_size + rhs.m_virtual_size,
-                       m_resident_size + rhs.m_resident_size,
-                       m_max_resident_size + rhs.m_max_resident_size);
+MemoryStats MemoryStats::operator+(const MemoryStats &rhs) {
+  return MemoryStats(m_virtual_size + rhs.m_virtual_size,
+                     m_resident_size + rhs.m_resident_size,
+                     m_max_resident_size + rhs.m_max_resident_size);
 }
 
-MemoryStats
-MemoryStats::operator / (size_t n)
-{
-    MemoryStats result(*this);
-    result.m_virtual_size /= n;
-    result.m_resident_size /= n;
-    result.m_max_resident_size /= n;
-    return result;
+MemoryStats MemoryStats::operator/(size_t n) {
+  MemoryStats result(*this);
+  result.m_virtual_size /= n;
+  result.m_resident_size /= n;
+  result.m_max_resident_size /= n;
+  return result;
 }
 
-MemoryStats
-MemoryStats::operator * (const MemoryStats& rhs)
-{
-    return MemoryStats(m_virtual_size * rhs.m_virtual_size,
-                       m_resident_size * rhs.m_resident_size,
-                       m_max_resident_size * rhs.m_max_resident_size);
+MemoryStats MemoryStats::operator*(const MemoryStats &rhs) {
+  return MemoryStats(m_virtual_size * rhs.m_virtual_size,
+                     m_resident_size * rhs.m_resident_size,
+                     m_max_resident_size * rhs.m_max_resident_size);
 }
 
-Results::ResultSP
-MemoryStats::GetResult (const char *name, const char *description) const
-{
-    std::unique_ptr<Results::Dictionary> dict_ap (new Results::Dictionary (name, NULL));
-    dict_ap->AddUnsigned("resident", NULL, GetResidentSize());
-    dict_ap->AddUnsigned("max_resident", NULL, GetMaxResidentSize());
-    return Results::ResultSP(dict_ap.release());
+Results::ResultSP MemoryStats::GetResult(const char *name,
+                                         const char *description) const {
+  std::unique_ptr<Results::Dictionary> dict_ap(
+      new Results::Dictionary(name, NULL));
+  dict_ap->AddUnsigned("resident", NULL, GetResidentSize());
+  dict_ap->AddUnsigned("max_resident", NULL, GetMaxResidentSize());
+  return Results::ResultSP(dict_ap.release());
 }
 
-MemoryGauge::ValueType
-MemoryGauge::Now ()
-{
-    task_t task = mach_task_self();
-    mach_task_basic_info_data_t taskBasicInfo;
-    mach_msg_type_number_t count = MACH_TASK_BASIC_INFO_COUNT;
-    auto task_info_ret = task_info(task, MACH_TASK_BASIC_INFO, (task_info_t) & taskBasicInfo, &count);
-    if (task_info_ret == KERN_SUCCESS) {
-        return MemoryStats(taskBasicInfo.virtual_size, taskBasicInfo.resident_size, taskBasicInfo.resident_size_max);
-    }
-    return 0;
+MemoryGauge::ValueType MemoryGauge::Now() {
+  task_t task = mach_task_self();
+  mach_task_basic_info_data_t taskBasicInfo;
+  mach_msg_type_number_t count = MACH_TASK_BASIC_INFO_COUNT;
+  auto task_info_ret = task_info(task, MACH_TASK_BASIC_INFO,
+                                 (task_info_t)&taskBasicInfo, &count);
+  if (task_info_ret == KERN_SUCCESS) {
+    return MemoryStats(taskBasicInfo.virtual_size, taskBasicInfo.resident_size,
+                       taskBasicInfo.resident_size_max);
+  }
+  return 0;
 }
 
-MemoryGauge::MemoryGauge () :
-    m_state(MemoryGauge::State::eNeverUsed),
-    m_start(),
-    m_delta()
-{
-}
+MemoryGauge::MemoryGauge()
+    : m_state(MemoryGauge::State::eNeverUsed), m_start(), m_delta() {}
 
-void
-MemoryGauge::Start ()
-{
-	m_state = MemoryGauge::State::eCounting;
-	m_start = Now();
+void MemoryGauge::Start() {
+  m_state = MemoryGauge::State::eCounting;
+  m_start = Now();
 }
 
-MemoryGauge::ValueType
-MemoryGauge::Stop ()
-{
-	m_stop = Now();
-	assert(m_state == MemoryGauge::State::eCounting && "cannot stop a non-started gauge");
-	m_state = MemoryGauge::State::eStopped;
-    m_delta = m_stop - m_start;
-	return m_delta;
+MemoryGauge::ValueType MemoryGauge::Stop() {
+  m_stop = Now();
+  assert(m_state == MemoryGauge::State::eCounting &&
+         "cannot stop a non-started gauge");
+  m_state = MemoryGauge::State::eStopped;
+  m_delta = m_stop - m_start;
+  return m_delta;
 }
 
-
-MemoryGauge::ValueType
-MemoryGauge::GetDeltaValue () const
-{
-	assert(m_state == MemoryGauge::State::eStopped && "gauge must be used before you can evaluate it");
-	return m_delta;
+MemoryGauge::ValueType MemoryGauge::GetDeltaValue() const {
+  assert(m_state == MemoryGauge::State::eStopped &&
+         "gauge must be used before you can evaluate it");
+  return m_delta;
 }
 
 template <>
-Results::ResultSP
-lldb_perf::GetResult (const char *description, MemoryStats value)
-{
-    return value.GetResult (NULL, description);
+Results::ResultSP lldb_perf::GetResult(const char *description,
+                                       MemoryStats value) {
+  return value.GetResult(NULL, description);
 }
 
-MemoryStats
-sqrt (const MemoryStats& arg)
-{
-    long double virt_size = arg.GetVirtualSize();
-    long double resident_size = arg.GetResidentSize();
-    long double max_resident_size = arg.GetMaxResidentSize();
-    
-    virt_size = sqrtl(virt_size);
-    resident_size = sqrtl(resident_size);
-    max_resident_size = sqrtl(max_resident_size);
-    
-    return MemoryStats(virt_size,resident_size,max_resident_size);
+MemoryStats sqrt(const MemoryStats &arg) {
+  long double virt_size = arg.GetVirtualSize();
+  long double resident_size = arg.GetResidentSize();
+  long double max_resident_size = arg.GetMaxResidentSize();
+
+  virt_size = sqrtl(virt_size);
+  resident_size = sqrtl(resident_size);
+  max_resident_size = sqrtl(max_resident_size);
+
+  return MemoryStats(virt_size, resident_size, max_resident_size);
 }
diff --git a/lldb/tools/lldb-perf/lib/MemoryGauge.h b/lldb/tools/lldb-perf/lib/MemoryGauge.h
index a1221b6..beed624 100644
--- a/lldb/tools/lldb-perf/lib/MemoryGauge.h
+++ b/lldb/tools/lldb-perf/lib/MemoryGauge.h
@@ -17,131 +17,76 @@
 
 namespace lldb_perf {
 
-class MemoryStats
-{
+class MemoryStats {
 public:
-    MemoryStats (mach_vm_size_t virtual_size = 0,
-                 mach_vm_size_t resident_size = 0,
-                 mach_vm_size_t max_resident_size = 0);
-    MemoryStats (const MemoryStats& rhs);
-    
-    MemoryStats&
-    operator = (const MemoryStats& rhs);
-
-    MemoryStats&
-    operator += (const MemoryStats& rhs);
-
-    MemoryStats
-    operator - (const MemoryStats& rhs);
-
-    MemoryStats
-    operator + (const MemoryStats& rhs);
-    
-    MemoryStats
-    operator / (size_t rhs);
-    
-    MemoryStats
-    operator * (const MemoryStats& rhs);
-    
-    mach_vm_size_t
-    GetVirtualSize () const
-    {
-        return m_virtual_size;
-    }
-    
-    mach_vm_size_t
-    GetResidentSize () const
-    {
-        return m_resident_size;
-    }
-    
-    mach_vm_size_t
-    GetMaxResidentSize () const
-    {
-        return m_max_resident_size;
-    }
-    
-    void
-    SetVirtualSize (mach_vm_size_t vs)
-    {
-        m_virtual_size = vs;
-    }
-    
-    void
-    SetResidentSize (mach_vm_size_t rs)
-    {
-        m_resident_size = rs;
-    }
-    
-    void
-    SetMaxResidentSize (mach_vm_size_t mrs)
-    {
-        m_max_resident_size = mrs;
-    }
-    
-    Results::ResultSP
-    GetResult (const char *name, const char *description) const;
+  MemoryStats(mach_vm_size_t virtual_size = 0, mach_vm_size_t resident_size = 0,
+              mach_vm_size_t max_resident_size = 0);
+  MemoryStats(const MemoryStats &rhs);
+
+  MemoryStats &operator=(const MemoryStats &rhs);
+
+  MemoryStats &operator+=(const MemoryStats &rhs);
+
+  MemoryStats operator-(const MemoryStats &rhs);
+
+  MemoryStats operator+(const MemoryStats &rhs);
+
+  MemoryStats operator/(size_t rhs);
+
+  MemoryStats operator*(const MemoryStats &rhs);
+
+  mach_vm_size_t GetVirtualSize() const { return m_virtual_size; }
+
+  mach_vm_size_t GetResidentSize() const { return m_resident_size; }
+
+  mach_vm_size_t GetMaxResidentSize() const { return m_max_resident_size; }
+
+  void SetVirtualSize(mach_vm_size_t vs) { m_virtual_size = vs; }
+
+  void SetResidentSize(mach_vm_size_t rs) { m_resident_size = rs; }
+
+  void SetMaxResidentSize(mach_vm_size_t mrs) { m_max_resident_size = mrs; }
+
+  Results::ResultSP GetResult(const char *name, const char *description) const;
+
 private:
-    mach_vm_size_t m_virtual_size;
-    mach_vm_size_t m_resident_size;
-    mach_vm_size_t m_max_resident_size;
+  mach_vm_size_t m_virtual_size;
+  mach_vm_size_t m_resident_size;
+  mach_vm_size_t m_max_resident_size;
 };
-    
-class MemoryGauge : public Gauge<MemoryStats>
-{
+
+class MemoryGauge : public Gauge<MemoryStats> {
 public:
-    MemoryGauge ();
-    
-    virtual
-    ~MemoryGauge ()
-    {
-    }
-    
-    void
-    Start ();
-    
-    ValueType
-    Stop ();
-    
-    virtual ValueType
-    GetStartValue() const
-    {
-        return m_start;
-    }
-
-    virtual ValueType
-    GetStopValue() const
-    {
-        return m_stop;
-    }
-
-    virtual ValueType
-    GetDeltaValue() const;
+  MemoryGauge();
+
+  virtual ~MemoryGauge() {}
+
+  void Start();
+
+  ValueType Stop();
+
+  virtual ValueType GetStartValue() const { return m_start; }
+
+  virtual ValueType GetStopValue() const { return m_stop; }
+
+  virtual ValueType GetDeltaValue() const;
 
 private:
-    enum class State
-    {
-        eNeverUsed,
-        eCounting,
-        eStopped
-    };
-    
-    ValueType
-    Now ();
-    
-    State m_state;
-    ValueType m_start;
-    ValueType m_stop;
-    ValueType m_delta;
+  enum class State { eNeverUsed, eCounting, eStopped };
+
+  ValueType Now();
+
+  State m_state;
+  ValueType m_start;
+  ValueType m_stop;
+  ValueType m_delta;
 };
 
 template <>
-Results::ResultSP
-GetResult (const char *description, MemoryStats value);
-    
+Results::ResultSP GetResult(const char *description, MemoryStats value);
+
 } // namespace lldb_perf
 
-lldb_perf::MemoryStats
-sqrt (const lldb_perf::MemoryStats& arg);
+lldb_perf::MemoryStats sqrt(const lldb_perf::MemoryStats &arg);
 
 #endif // #ifndef __PerfTestDriver__MemoryGauge__
diff --git a/lldb/tools/lldb-perf/lib/Metric.cpp b/lldb/tools/lldb-perf/lib/Metric.cpp
index 1951cdb0..f049e6c 100644
--- a/lldb/tools/lldb-perf/lib/Metric.cpp
+++ b/lldb/tools/lldb-perf/lib/Metric.cpp
@@ -13,72 +13,47 @@
 
 using namespace lldb_perf;
 
-template <class T>
-Metric<T>::Metric () : Metric ("")
-{
-}
+template <class T> Metric<T>::Metric() : Metric("") {}
 
 template <class T>
-Metric<T>::Metric (const char* n, const char* d) :
-    m_name(n ? n : ""),
-    m_description(d ? d : ""),
-    m_dataset ()
-{
-}
+Metric<T>::Metric(const char *n, const char *d)
+    : m_name(n ? n : ""), m_description(d ? d : ""), m_dataset() {}
 
-template <class T>
-void
-Metric<T>::Append (T v)
-{
-    m_dataset.push_back(v);
-}
+template <class T> void Metric<T>::Append(T v) { m_dataset.push_back(v); }
 
-template <class T>
-size_t
-Metric<T>::GetCount () const
-{
-    return m_dataset.size();
+template <class T> size_t Metric<T>::GetCount() const {
+  return m_dataset.size();
 }
 
-template <class T>
-T
-Metric<T>::GetSum () const
-{
-    T sum = 0;
-    for (auto v : m_dataset)
-        sum += v;
-    return sum;
+template <class T> T Metric<T>::GetSum() const {
+  T sum = 0;
+  for (auto v : m_dataset)
+    sum += v;
+  return sum;
 }
 
-template <class T>
-T
-Metric<T>::GetAverage () const
-{
-    return GetSum()/GetCount();
+template <class T> T Metric<T>::GetAverage() const {
+  return GetSum() / GetCount();
 }
 
-
 // Knuth's algorithm for stddev - massive cancellation resistant
 template <class T>
-T
-Metric<T>::GetStandardDeviation (StandardDeviationMode mode) const
-{
-    size_t n = 0;
-    T mean = 0;
-    T M2 = 0;
-    for (auto x : m_dataset)
-    {
-        n = n + 1;
-        T delta = x - mean;
-        mean = mean + delta/n;
-        M2 = M2+delta*(x-mean);
-    }
-    T variance;
-    if (mode == StandardDeviationMode::ePopulation || n == 1)
-        variance = M2 / n;
-    else
-        variance = M2 / (n - 1);
-    return sqrt(variance);
+T Metric<T>::GetStandardDeviation(StandardDeviationMode mode) const {
+  size_t n = 0;
+  T mean = 0;
+  T M2 = 0;
+  for (auto x : m_dataset) {
+    n = n + 1;
+    T delta = x - mean;
+    mean = mean + delta / n;
+    M2 = M2 + delta * (x - mean);
+  }
+  T variance;
+  if (mode == StandardDeviationMode::ePopulation || n == 1)
+    variance = M2 / n;
+  else
+    variance = M2 / (n - 1);
+  return sqrt(variance);
 }
 
 template class lldb_perf::Metric<double>;
diff --git a/lldb/tools/lldb-perf/lib/Metric.h b/lldb/tools/lldb-perf/lib/Metric.h
index 45342d2..bee02cb 100644
--- a/lldb/tools/lldb-perf/lib/Metric.h
+++ b/lldb/tools/lldb-perf/lib/Metric.h
@@ -10,62 +10,48 @@
 #ifndef __PerfTestDriver__Metric__
 #define __PerfTestDriver__Metric__
 
-#include <vector>
-#include <string>
 #include <mach/task_info.h>
+#include <string>
+#include <vector>
 
 namespace lldb_perf {
 
 class MemoryStats;
 
-template <class ValueType>
-class Metric
-{
+template <class ValueType> class Metric {
 public:
-    enum class StandardDeviationMode
-    {
-        eSample,
-        ePopulation
-    };
-    
-    Metric ();
-    Metric (const char*, const char* = NULL);
-    
-    void
-    Append (ValueType v);
-    
-    ValueType
-    GetAverage () const;
-    
-    size_t
-    GetCount () const;
-    
-    ValueType
-    GetSum () const;
-    
-    ValueType
-    GetStandardDeviation (StandardDeviationMode mode = StandardDeviationMode::ePopulation) const;
-    
-    const char*
-    GetName () const
-    {
-        if (m_name.empty())
-            return NULL;
-        return m_name.c_str();
-    }
+  enum class StandardDeviationMode { eSample, ePopulation };
+
+  Metric();
+  Metric(const char *, const char * = NULL);
+
+  void Append(ValueType v);
+
+  ValueType GetAverage() const;
+
+  size_t GetCount() const;
+
+  ValueType GetSum() const;
+
+  ValueType GetStandardDeviation(
+      StandardDeviationMode mode = StandardDeviationMode::ePopulation) const;
+
+  const char *GetName() const {
+    if (m_name.empty())
+      return NULL;
+    return m_name.c_str();
+  }
 
-    const char*
-    GetDescription () const
-    {
-        if (m_description.empty())
-            return NULL;
-        return m_description.c_str();
-    }
+  const char *GetDescription() const {
+    if (m_description.empty())
+      return NULL;
+    return m_description.c_str();
+  }
 
 private:
-    std::string m_name;
-    std::string m_description;
-    std::vector<ValueType> m_dataset;
+  std::string m_name;
+  std::string m_description;
+  std::vector<ValueType> m_dataset;
 };
 }
 
diff --git a/lldb/tools/lldb-perf/lib/Results.cpp b/lldb/tools/lldb-perf/lib/Results.cpp
index 6abf67e..17a022f 100644
--- a/lldb/tools/lldb-perf/lib/Results.cpp
+++ b/lldb/tools/lldb-perf/lib/Results.cpp
@@ -19,257 +19,221 @@
 
 using namespace lldb_perf;
 
-static void
-AddResultToArray (CFCMutableArray &array, Results::Result *result);
-
-static void
-AddResultToDictionary (CFCMutableDictionary &parent_dict, const char *key, Results::Result *result);
-
-static void
-AddResultToArray (CFCMutableArray &parent_array, Results::Result *result)
-{
-    switch (result->GetType())
-    {
-    case Results::Result::Type::Invalid:
-        break;
-            
-    case Results::Result::Type::Array:
-        {
-            Results::Array *value = result->GetAsArray();
-            CFCMutableArray array;
-            value->ForEach([&array](const Results::ResultSP &value_sp) -> bool
-                           {
-                               AddResultToArray (array, value_sp.get());
-                               return true;
-                           });
-            parent_array.AppendValue(array.get(), true);
-        }
-        break;
-
-    case Results::Result::Type::Dictionary:
-        {
-            Results::Dictionary *value = result->GetAsDictionary();
-            CFCMutableDictionary dict;
-            value->ForEach([&dict](const std::string &key, const Results::ResultSP &value_sp) -> bool
-                           {
-                               AddResultToDictionary (dict, key.c_str(), value_sp.get());
-                               return true;
-                           });
-            if (result->GetDescription())
-            {
-                dict.AddValueCString(CFSTR("description"), result->GetDescription());
-            }
-            parent_array.AppendValue(dict.get(), true);
-        }
-        break;
-    
-    case Results::Result::Type::Double:
-        {
-            double d = result->GetAsDouble()->GetValue();
-            CFCReleaser<CFNumberRef> cf_number(::CFNumberCreate (kCFAllocatorDefault, kCFNumberDoubleType, &d));
-            if (cf_number.get())
-                parent_array.AppendValue(cf_number.get(), true);
-        }
-        break;
-    case Results::Result::Type::String:
-        {
-            CFCString cfstr (result->GetAsString()->GetValue());
-            if (cfstr.get())
-                parent_array.AppendValue(cfstr.get(), true);
-        }
-        break;
-            
-    case Results::Result::Type::Unsigned:
-        {
-            uint64_t uval64 = result->GetAsUnsigned()->GetValue();
-            CFCReleaser<CFNumberRef> cf_number(::CFNumberCreate (kCFAllocatorDefault, kCFNumberSInt64Type, &uval64));
-            if (cf_number.get())
-                parent_array.AppendValue(cf_number.get(), true);
-        }
-        break;
-
-    default:
-        assert (!"unhandled result");
-        break;
+static void AddResultToArray(CFCMutableArray &array, Results::Result *result);
+
+static void AddResultToDictionary(CFCMutableDictionary &parent_dict,
+                                  const char *key, Results::Result *result);
+
+static void AddResultToArray(CFCMutableArray &parent_array,
+                             Results::Result *result) {
+  switch (result->GetType()) {
+  case Results::Result::Type::Invalid:
+    break;
+
+  case Results::Result::Type::Array: {
+    Results::Array *value = result->GetAsArray();
+    CFCMutableArray array;
+    value->ForEach([&array](const Results::ResultSP &value_sp) -> bool {
+      AddResultToArray(array, value_sp.get());
+      return true;
+    });
+    parent_array.AppendValue(array.get(), true);
+  } break;
+
+  case Results::Result::Type::Dictionary: {
+    Results::Dictionary *value = result->GetAsDictionary();
+    CFCMutableDictionary dict;
+    value->ForEach([&dict](const std::string &key,
+                           const Results::ResultSP &value_sp) -> bool {
+      AddResultToDictionary(dict, key.c_str(), value_sp.get());
+      return true;
+    });
+    if (result->GetDescription()) {
+      dict.AddValueCString(CFSTR("description"), result->GetDescription());
     }
+    parent_array.AppendValue(dict.get(), true);
+  } break;
+
+  case Results::Result::Type::Double: {
+    double d = result->GetAsDouble()->GetValue();
+    CFCReleaser<CFNumberRef> cf_number(
+        ::CFNumberCreate(kCFAllocatorDefault, kCFNumberDoubleType, &d));
+    if (cf_number.get())
+      parent_array.AppendValue(cf_number.get(), true);
+  } break;
+  case Results::Result::Type::String: {
+    CFCString cfstr(result->GetAsString()->GetValue());
+    if (cfstr.get())
+      parent_array.AppendValue(cfstr.get(), true);
+  } break;
+
+  case Results::Result::Type::Unsigned: {
+    uint64_t uval64 = result->GetAsUnsigned()->GetValue();
+    CFCReleaser<CFNumberRef> cf_number(
+        ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt64Type, &uval64));
+    if (cf_number.get())
+      parent_array.AppendValue(cf_number.get(), true);
+  } break;
+
+  default:
+    assert(!"unhandled result");
+    break;
+  }
 }
 
-
-static void
-AddResultToDictionary (CFCMutableDictionary &parent_dict, const char *key, Results::Result *result)
-{
-    assert (key && key[0]);
-    CFCString cf_key(key);
-    switch (result->GetType())
-    {
-    case Results::Result::Type::Invalid:
-        break;
-    
-    case Results::Result::Type::Array:
-        {
-            Results::Array *value = result->GetAsArray();
-            CFCMutableArray array;
-            value->ForEach([&array](const Results::ResultSP &value_sp) -> bool
-                           {
-                               AddResultToArray (array, value_sp.get());
-                               return true;
-                           });
-            parent_dict.AddValue(cf_key.get(), array.get(), true);
-        }
-        break;
-    case Results::Result::Type::Dictionary:
-        {
-            Results::Dictionary *value = result->GetAsDictionary();
-            CFCMutableDictionary dict;
-            value->ForEach([&dict](const std::string &key, const Results::ResultSP &value_sp) -> bool
-                           {
-                               AddResultToDictionary (dict, key.c_str(), value_sp.get());
-                               return true;
-                           });
-            if (result->GetDescription())
-            {
-                dict.AddValueCString(CFSTR("description"), result->GetDescription());
-            }
-            parent_dict.AddValue(cf_key.get(), dict.get(), true);
-        }
-        break;
-    case Results::Result::Type::Double:
-        {
-            parent_dict.SetValueDouble(cf_key.get(), result->GetAsDouble()->GetValue(), true);
-        }
-        break;
-    case Results::Result::Type::String:
-        {
-            parent_dict.SetValueCString(cf_key.get(), result->GetAsString()->GetValue(), true);
-        }
-        break;
-
-    case Results::Result::Type::Unsigned:
-        {
-            parent_dict.SetValueUInt64 (cf_key.get(), result->GetAsUnsigned()->GetValue(), true);
-        }
-        break;
-    default:
-        assert (!"unhandled result");
-        break;
+static void AddResultToDictionary(CFCMutableDictionary &parent_dict,
+                                  const char *key, Results::Result *result) {
+  assert(key && key[0]);
+  CFCString cf_key(key);
+  switch (result->GetType()) {
+  case Results::Result::Type::Invalid:
+    break;
+
+  case Results::Result::Type::Array: {
+    Results::Array *value = result->GetAsArray();
+    CFCMutableArray array;
+    value->ForEach([&array](const Results::ResultSP &value_sp) -> bool {
+      AddResultToArray(array, value_sp.get());
+      return true;
+    });
+    parent_dict.AddValue(cf_key.get(), array.get(), true);
+  } break;
+  case Results::Result::Type::Dictionary: {
+    Results::Dictionary *value = result->GetAsDictionary();
+    CFCMutableDictionary dict;
+    value->ForEach([&dict](const std::string &key,
+                           const Results::ResultSP &value_sp) -> bool {
+      AddResultToDictionary(dict, key.c_str(), value_sp.get());
+      return true;
+    });
+    if (result->GetDescription()) {
+      dict.AddValueCString(CFSTR("description"), result->GetDescription());
     }
+    parent_dict.AddValue(cf_key.get(), dict.get(), true);
+  } break;
+  case Results::Result::Type::Double: {
+    parent_dict.SetValueDouble(cf_key.get(), result->GetAsDouble()->GetValue(),
+                               true);
+  } break;
+  case Results::Result::Type::String: {
+    parent_dict.SetValueCString(cf_key.get(), result->GetAsString()->GetValue(),
+                                true);
+  } break;
+
+  case Results::Result::Type::Unsigned: {
+    parent_dict.SetValueUInt64(cf_key.get(),
+                               result->GetAsUnsigned()->GetValue(), true);
+  } break;
+  default:
+    assert(!"unhandled result");
+    break;
+  }
 }
-void
-Results::Write (const char *out_path)
-{
+void Results::Write(const char *out_path) {
 #ifdef __APPLE__
-    CFCMutableDictionary dict;
-    
-    m_results.ForEach([&dict](const std::string &key, const ResultSP &value_sp) -> bool
-                      {
-                          AddResultToDictionary (dict, key.c_str(), value_sp.get());
-                          return true;
-                      });
-    CFDataRef xmlData = CFPropertyListCreateData(kCFAllocatorDefault, dict.get(), kCFPropertyListXMLFormat_v1_0, 0, NULL);
-    
-    if (out_path == NULL)
-        out_path = "/dev/stdout";
+  CFCMutableDictionary dict;
+
+  m_results.ForEach(
+      [&dict](const std::string &key, const ResultSP &value_sp) -> bool {
+        AddResultToDictionary(dict, key.c_str(), value_sp.get());
+        return true;
+      });
+  CFDataRef xmlData = CFPropertyListCreateData(
+      kCFAllocatorDefault, dict.get(), kCFPropertyListXMLFormat_v1_0, 0, NULL);
+
+  if (out_path == NULL)
+    out_path = "/dev/stdout";
+
+  CFURLRef file = CFURLCreateFromFileSystemRepresentation(
+      NULL, (const UInt8 *)out_path, strlen(out_path), FALSE);
 
-    CFURLRef file = CFURLCreateFromFileSystemRepresentation(NULL, (const UInt8*)out_path, strlen(out_path), FALSE);
-    
-    CFURLWriteDataAndPropertiesToResource(file, xmlData, NULL, NULL);
+  CFURLWriteDataAndPropertiesToResource(file, xmlData, NULL, NULL);
 #endif
 }
 
-Results::ResultSP
-Results::Dictionary::AddUnsigned (const char *name, const char *description, uint64_t value)
-{
-    assert (name && name[0]);
-    if (description && description[0])
-    {
-        std::unique_ptr<Results::Dictionary> value_dict_ap (new Results::Dictionary ());
-        value_dict_ap->AddString("description", NULL, description);
-        value_dict_ap->AddUnsigned("value", NULL, value);
-        m_dictionary[std::string(name)] = ResultSP (value_dict_ap.release());
-    }
-    else
-        m_dictionary[std::string(name)] = ResultSP (new Unsigned (name, description, value));
-    return m_dictionary[std::string(name)];
+Results::ResultSP Results::Dictionary::AddUnsigned(const char *name,
+                                                   const char *description,
+                                                   uint64_t value) {
+  assert(name && name[0]);
+  if (description && description[0]) {
+    std::unique_ptr<Results::Dictionary> value_dict_ap(
+        new Results::Dictionary());
+    value_dict_ap->AddString("description", NULL, description);
+    value_dict_ap->AddUnsigned("value", NULL, value);
+    m_dictionary[std::string(name)] = ResultSP(value_dict_ap.release());
+  } else
+    m_dictionary[std::string(name)] =
+        ResultSP(new Unsigned(name, description, value));
+  return m_dictionary[std::string(name)];
 }
 
-Results::ResultSP
-Results::Dictionary::AddDouble (const char *name, const char *description, double value)
-{
-    assert (name && name[0]);
-    
-    if (description && description[0])
-    {
-        std::unique_ptr<Results::Dictionary> value_dict_ap (new Results::Dictionary ());
-        value_dict_ap->AddString("description", NULL, description);
-        value_dict_ap->AddDouble("value", NULL, value);
-        m_dictionary[std::string(name)] = ResultSP (value_dict_ap.release());
-    }
-    else
-        m_dictionary[std::string(name)] = ResultSP (new Double (name, description, value));
-    return m_dictionary[std::string(name)];
+Results::ResultSP Results::Dictionary::AddDouble(const char *name,
+                                                 const char *description,
+                                                 double value) {
+  assert(name && name[0]);
+
+  if (description && description[0]) {
+    std::unique_ptr<Results::Dictionary> value_dict_ap(
+        new Results::Dictionary());
+    value_dict_ap->AddString("description", NULL, description);
+    value_dict_ap->AddDouble("value", NULL, value);
+    m_dictionary[std::string(name)] = ResultSP(value_dict_ap.release());
+  } else
+    m_dictionary[std::string(name)] =
+        ResultSP(new Double(name, description, value));
+  return m_dictionary[std::string(name)];
 }
-Results::ResultSP
-Results::Dictionary::AddString (const char *name, const char *description, const char *value)
-{
-    assert (name && name[0]);
-    if (description && description[0])
-    {
-        std::unique_ptr<Results::Dictionary> value_dict_ap (new Results::Dictionary ());
-        value_dict_ap->AddString("description", NULL, description);
-        value_dict_ap->AddString("value", NULL, value);
-        m_dictionary[std::string(name)] = ResultSP (value_dict_ap.release());
-    }
-    else
-        m_dictionary[std::string(name)] = ResultSP (new String (name, description, value));
-    return m_dictionary[std::string(name)];
+Results::ResultSP Results::Dictionary::AddString(const char *name,
+                                                 const char *description,
+                                                 const char *value) {
+  assert(name && name[0]);
+  if (description && description[0]) {
+    std::unique_ptr<Results::Dictionary> value_dict_ap(
+        new Results::Dictionary());
+    value_dict_ap->AddString("description", NULL, description);
+    value_dict_ap->AddString("value", NULL, value);
+    m_dictionary[std::string(name)] = ResultSP(value_dict_ap.release());
+  } else
+    m_dictionary[std::string(name)] =
+        ResultSP(new String(name, description, value));
+  return m_dictionary[std::string(name)];
 }
 
-Results::ResultSP
-Results::Dictionary::Add (const char *name, const char *description, const ResultSP &result_sp)
-{
-    assert (name && name[0]);
-    if (description && description[0])
-    {
-        std::unique_ptr<Results::Dictionary> value_dict_ap (new Results::Dictionary ());
-        value_dict_ap->AddString("description", NULL, description);
-        value_dict_ap->Add("value", NULL, result_sp);
-        m_dictionary[std::string(name)] = ResultSP (value_dict_ap.release());
-    }
-    else
-        m_dictionary[std::string(name)] = result_sp;
-    return m_dictionary[std::string(name)];
+Results::ResultSP Results::Dictionary::Add(const char *name,
+                                           const char *description,
+                                           const ResultSP &result_sp) {
+  assert(name && name[0]);
+  if (description && description[0]) {
+    std::unique_ptr<Results::Dictionary> value_dict_ap(
+        new Results::Dictionary());
+    value_dict_ap->AddString("description", NULL, description);
+    value_dict_ap->Add("value", NULL, result_sp);
+    m_dictionary[std::string(name)] = ResultSP(value_dict_ap.release());
+  } else
+    m_dictionary[std::string(name)] = result_sp;
+  return m_dictionary[std::string(name)];
 }
 
-void
-Results::Dictionary::ForEach (const std::function <bool (const std::string &, const ResultSP &)> &callback)
-{
-    collection::const_iterator pos, end = m_dictionary.end();
-    for (pos = m_dictionary.begin(); pos != end; ++pos)
-    {
-        if (callback (pos->first.c_str(), pos->second) == false)
-            return;
-    }
+void Results::Dictionary::ForEach(
+    const std::function<bool(const std::string &, const ResultSP &)>
+        &callback) {
+  collection::const_iterator pos, end = m_dictionary.end();
+  for (pos = m_dictionary.begin(); pos != end; ++pos) {
+    if (callback(pos->first.c_str(), pos->second) == false)
+      return;
+  }
 }
 
-
-
-Results::ResultSP
-Results::Array::Append (const ResultSP &result_sp)
-{
-    m_array.push_back (result_sp);
-    return result_sp;
+Results::ResultSP Results::Array::Append(const ResultSP &result_sp) {
+  m_array.push_back(result_sp);
+  return result_sp;
 }
 
-void
-Results::Array::ForEach (const std::function <bool (const ResultSP &)> &callback)
-{
-    collection::const_iterator pos, end = m_array.end();
-    for (pos = m_array.begin(); pos != end; ++pos)
-    {
-        if (callback (*pos) == false)
-            return;
-    }
+void Results::Array::ForEach(
+    const std::function<bool(const ResultSP &)> &callback) {
+  collection::const_iterator pos, end = m_array.end();
+  for (pos = m_array.begin(); pos != end; ++pos) {
+    if (callback(*pos) == false)
+      return;
+  }
 }
-
-
-
diff --git a/lldb/tools/lldb-perf/lib/Results.h b/lldb/tools/lldb-perf/lib/Results.h
index 388077e..a3d467ff 100644
--- a/lldb/tools/lldb-perf/lib/Results.h
+++ b/lldb/tools/lldb-perf/lib/Results.h
@@ -17,296 +17,189 @@
 
 namespace lldb_perf {
 
-class Results
-{
+class Results {
 public:
-    class Array;
-    class Dictionary;
-    class Double;
-    class String;
-    class Unsigned;
-
-    class Result
-    {
-    public:
-        enum class Type
-        {
-            Invalid,
-            Array,
-            Dictionary,
-            Double,
-            String,
-            Unsigned
-        };
-
-        Result (Type type, const char *name, const char *description) :
-            m_name (),
-            m_description(),
-            m_type (type)
-        {
-            if (name && name[0])
-                m_name = name;
-            if (description && description[0])
-                m_description = description;
-        }
-
-        virtual
-        ~Result()
-        {
-        }
-
-        virtual void
-        Write (Results &results) = 0;
-
-        Array *
-        GetAsArray ()
-        {
-            if (m_type == Type::Array)
-                return (Array *)this;
-            return NULL;
-        }
-        Dictionary *
-        GetAsDictionary ()
-        {
-            if (m_type == Type::Dictionary)
-                return (Dictionary *)this;
-            return NULL;
-        }
-        Double *
-        GetAsDouble ()
-        {
-            if (m_type == Type::Double)
-                return (Double *)this;
-            return NULL;
-        }
-
-        String *
-        GetAsString ()
-        {
-            if (m_type == Type::String)
-                return (String *)this;
-            return NULL;
-        }
-        Unsigned *
-        GetAsUnsigned ()
-        {
-            if (m_type == Type::Unsigned)
-                return (Unsigned *)this;
-            return NULL;
-        }
-        
-        const char *
-        GetName() const
-        {
-            if (m_name.empty())
-                return NULL;
-            return m_name.c_str();
-        }
-
-        const char *
-        GetDescription() const
-        {
-            if (m_description.empty())
-                return NULL;
-            return m_description.c_str();
-        }
-
-        Type
-        GetType() const
-        {
-            return m_type;
-        }
-    
-    protected:
-        std::string m_name;
-        std::string m_description;
-        Type m_type;
-    };
-    
-    typedef std::shared_ptr<Result> ResultSP;
-
-    class Array : public Result
-    {
-    public:
-        Array (const char *name, const char *description) :
-            Result (Type::Array, name, description)
-        {
-        }
-        
-        virtual
-        ~Array()
-        {
-        }
-        
-        ResultSP
-        Append (const ResultSP &result_sp);
-
-        void
-        ForEach (const std::function <bool (const ResultSP &)> &callback);
-
-        virtual void
-        Write (Results &results)
-        {
-        }
-    protected:
-        typedef std::vector<ResultSP> collection;
-        collection m_array;
-    };
-
-    class Dictionary : public Result
-    {
-    public:
-        Dictionary () :
-            Result (Type::Dictionary, NULL, NULL)
-        {
-        }
-
-        Dictionary (const char *name, const char *description) :
-            Result (Type::Dictionary, name, description)
-        {
-        }
-
-        virtual
-        ~Dictionary()
-        {
-        }
-
-        virtual void
-        Write (Results &results)
-        {
-        }
-
-        void
-        ForEach (const std::function <bool (const std::string &, const ResultSP &)> &callback);
-    
-        ResultSP
-        Add (const char *name, const char *description, const ResultSP &result_sp);
-        
-        ResultSP
-        AddDouble (const char *name, const char *descriptiorn, double value);
-        
-        ResultSP
-        AddUnsigned (const char *name, const char *description, uint64_t value);
-
-        ResultSP
-        AddString (const char *name, const char *description, const char *value);
-
-    protected:
-
-        typedef std::map<std::string, ResultSP> collection;
-        collection m_dictionary;
-    };
-    
-    class String : public Result
-    {
-    public:
-        String (const char *name, const char *description, const char *value) :
-            Result (Type::String, name, description),
-            m_string ()
-        {
-            if (value && value[0])
-                m_string = value;
-        }
-
-        virtual
-        ~String()
-        {
-        }
-
-        virtual void
-        Write (Results &results)
-        {
-        }
-
-        const char *
-        GetValue () const
-        {
-            return m_string.empty() ? NULL : m_string.c_str();
-        }
-        
-    protected:
-        std::string m_string;
-    };
-
-    class Double : public Result
-    {
-    public:
-        Double (const char *name, const char *description, double value) :
-            Result (Type::Double, name, description),
-            m_double (value)
-        {
-        }
-        
-        virtual
-        ~Double()
-        {
-        }
-        
-        virtual void
-        Write (Results &results)
-        {
-        }
-        
-        double
-        GetValue () const
-        {
-            return m_double;
-        }
-        
-    protected:
-        double m_double;
-    };
-
-    class Unsigned : public Result
-    {
-    public:
-        Unsigned (const char *name, const char *description, uint64_t value) :
-            Result (Type::Unsigned, name, description),
-            m_unsigned (value)
-        {
-        }
-        
-        virtual
-        ~Unsigned()
-        {
-        }
-
-        virtual void
-        Write (Results &results)
-        {
-        }
-        
-        uint64_t
-        GetValue () const
-        {
-            return m_unsigned;
-        }
-
-    protected:
-        uint64_t m_unsigned;
-    };
-
-    Results () :
-        m_results ()
-    {
+  class Array;
+  class Dictionary;
+  class Double;
+  class String;
+  class Unsigned;
+
+  class Result {
+  public:
+    enum class Type { Invalid, Array, Dictionary, Double, String, Unsigned };
+
+    Result(Type type, const char *name, const char *description)
+        : m_name(), m_description(), m_type(type) {
+      if (name && name[0])
+        m_name = name;
+      if (description && description[0])
+        m_description = description;
     }
-    
-    ~Results()
-    {
+
+    virtual ~Result() {}
+
+    virtual void Write(Results &results) = 0;
+
+    Array *GetAsArray() {
+      if (m_type == Type::Array)
+        return (Array *)this;
+      return NULL;
+    }
+    Dictionary *GetAsDictionary() {
+      if (m_type == Type::Dictionary)
+        return (Dictionary *)this;
+      return NULL;
+    }
+    Double *GetAsDouble() {
+      if (m_type == Type::Double)
+        return (Double *)this;
+      return NULL;
+    }
+
+    String *GetAsString() {
+      if (m_type == Type::String)
+        return (String *)this;
+      return NULL;
+    }
+    Unsigned *GetAsUnsigned() {
+      if (m_type == Type::Unsigned)
+        return (Unsigned *)this;
+      return NULL;
+    }
+
+    const char *GetName() const {
+      if (m_name.empty())
+        return NULL;
+      return m_name.c_str();
+    }
+
+    const char *GetDescription() const {
+      if (m_description.empty())
+        return NULL;
+      return m_description.c_str();
+    }
+
+    Type GetType() const { return m_type; }
+
+  protected:
+    std::string m_name;
+    std::string m_description;
+    Type m_type;
+  };
+
+  typedef std::shared_ptr<Result> ResultSP;
+
+  class Array : public Result {
+  public:
+    Array(const char *name, const char *description)
+        : Result(Type::Array, name, description) {}
+
+    virtual ~Array() {}
+
+    ResultSP Append(const ResultSP &result_sp);
+
+    void ForEach(const std::function<bool(const ResultSP &)> &callback);
+
+    virtual void Write(Results &results) {}
+
+  protected:
+    typedef std::vector<ResultSP> collection;
+    collection m_array;
+  };
+
+  class Dictionary : public Result {
+  public:
+    Dictionary() : Result(Type::Dictionary, NULL, NULL) {}
+
+    Dictionary(const char *name, const char *description)
+        : Result(Type::Dictionary, name, description) {}
+
+    virtual ~Dictionary() {}
+
+    virtual void Write(Results &results) {}
+
+    void ForEach(const std::function<bool(const std::string &,
+                                          const ResultSP &)> &callback);
+
+    ResultSP Add(const char *name, const char *description,
+                 const ResultSP &result_sp);
+
+    ResultSP AddDouble(const char *name, const char *descriptiorn,
+                       double value);
+
+    ResultSP AddUnsigned(const char *name, const char *description,
+                         uint64_t value);
+
+    ResultSP AddString(const char *name, const char *description,
+                       const char *value);
+
+  protected:
+    typedef std::map<std::string, ResultSP> collection;
+    collection m_dictionary;
+  };
+
+  class String : public Result {
+  public:
+    String(const char *name, const char *description, const char *value)
+        : Result(Type::String, name, description), m_string() {
+      if (value && value[0])
+        m_string = value;
     }
-    
-    Dictionary &
-    GetDictionary ()
-    {
-        return m_results;
+
+    virtual ~String() {}
+
+    virtual void Write(Results &results) {}
+
+    const char *GetValue() const {
+      return m_string.empty() ? NULL : m_string.c_str();
     }
 
-    void
-    Write (const char *path);
-    
+  protected:
+    std::string m_string;
+  };
+
+  class Double : public Result {
+  public:
+    Double(const char *name, const char *description, double value)
+        : Result(Type::Double, name, description), m_double(value) {}
+
+    virtual ~Double() {}
+
+    virtual void Write(Results &results) {}
+
+    double GetValue() const { return m_double; }
+
+  protected:
+    double m_double;
+  };
+
+  class Unsigned : public Result {
+  public:
+    Unsigned(const char *name, const char *description, uint64_t value)
+        : Result(Type::Unsigned, name, description), m_unsigned(value) {}
+
+    virtual ~Unsigned() {}
+
+    virtual void Write(Results &results) {}
+
+    uint64_t GetValue() const { return m_unsigned; }
+
+  protected:
+    uint64_t m_unsigned;
+  };
+
+  Results() : m_results() {}
+
+  ~Results() {}
+
+  Dictionary &GetDictionary() { return m_results; }
+
+  void Write(const char *path);
+
 protected:
-    Dictionary m_results;
+  Dictionary m_results;
 };
-    
+
 } // namespace lldb_perf
 #endif // #ifndef __PerfTestDriver_Results_h__
diff --git a/lldb/tools/lldb-perf/lib/TestCase.cpp b/lldb/tools/lldb-perf/lib/TestCase.cpp
index c23a5e5..3939489 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;
 }
-
diff --git a/lldb/tools/lldb-perf/lib/TestCase.h b/lldb/tools/lldb-perf/lib/TestCase.h
index 811d043..8ec1a47 100644
--- a/lldb/tools/lldb-perf/lib/TestCase.h
+++ b/lldb/tools/lldb-perf/lib/TestCase.h
@@ -10,195 +10,135 @@
 #ifndef __PerfTestDriver__TestCase__
 #define __PerfTestDriver__TestCase__
 
-#include "lldb/API/LLDB.h"
 #include "Measurement.h"
+#include "lldb/API/LLDB.h"
 #include <getopt.h>
 
 namespace lldb_perf {
 
 class Results;
-    
-class TestCase
-{
+
+class TestCase {
 public:
-    TestCase();
-    
-    struct ActionWanted
-	{
-		enum class Type
-		{
-			eStepOver,
-			eContinue,
-            eStepOut,
-            eRelaunch,
-            eCallNext,
-            eNone,
-			eKill
-		} type;
-		lldb::SBThread thread;
-        lldb::SBLaunchInfo launch_info;
-        
-        ActionWanted () :
-            type (Type::eContinue),
-            thread (),
-            launch_info (NULL)
-        {
-        }
-        
-        void
-        None ()
-        {
-            type = Type::eNone;
-            thread = lldb::SBThread();
-        }
-
-        void
-        Continue()
-        {
-            type = Type::eContinue;
-            thread = lldb::SBThread();
-        }
-        
-        void
-        StepOver (lldb::SBThread t)
-        {
-            type = Type::eStepOver;
-            thread = t;
-        }
-
-        void
-        StepOut (lldb::SBThread t)
-        {
-            type = Type::eStepOut;
-            thread = t;
-        }
-        
-        void
-        Relaunch (lldb::SBLaunchInfo l)
-        {
-            type = Type::eRelaunch;
-            thread = lldb::SBThread();
-            launch_info = l;
-        }
-        
-        void
-        Kill ()
-        {
-            type = Type::eKill;
-            thread = lldb::SBThread();
-        }
-        
-        void
-        CallNext ()
-        {
-            type = Type::eCallNext;
-            thread = lldb::SBThread();
-        }
-	};
-    
-    virtual
-    ~TestCase ()
-    {
-    }
-    
-	virtual bool
-	Setup (int& argc, const char**& argv);
-    
-	virtual void
-	TestStep (int counter, ActionWanted &next_action) = 0;
-	
-	bool
-	Launch (lldb::SBLaunchInfo &launch_info);
-	
-    bool
-	Launch (std::initializer_list<const char*> args = {});
-    
-	void
-	Loop();
-    
-    void
-    SetVerbose (bool);
-    
-    bool
-    GetVerbose ();
-    
-    virtual void
-    WriteResults (Results &results) = 0;
-    
-    template <typename G,typename A>
-    Measurement<G,A> CreateMeasurement (A a, const char* name = NULL, const char* description = NULL)
-    {
-        return Measurement<G,A> (a,name, description);
-    }
-    
-    template <typename A>
-    TimeMeasurement<A> CreateTimeMeasurement (A a, const char* name = NULL, const char* description = NULL)
-    {
-        return TimeMeasurement<A> (a,name, description);
-    }
-    
-    template <typename A>
-    MemoryMeasurement<A> CreateMemoryMeasurement (A a, const char* name = NULL, const char* description = NULL)
-    {
-        return MemoryMeasurement<A> (a,name, description);
-    }
-    
-    static int
-    Run (TestCase& test, int argc, const char** argv);
-    
-    virtual bool
-    ParseOption (int short_option, const char* optarg)
-    {
-        return false;
+  TestCase();
+
+  struct ActionWanted {
+    enum class Type {
+      eStepOver,
+      eContinue,
+      eStepOut,
+      eRelaunch,
+      eCallNext,
+      eNone,
+      eKill
+    } type;
+    lldb::SBThread thread;
+    lldb::SBLaunchInfo launch_info;
+
+    ActionWanted() : type(Type::eContinue), thread(), launch_info(NULL) {}
+
+    void None() {
+      type = Type::eNone;
+      thread = lldb::SBThread();
     }
-    
-    virtual struct option*
-    GetLongOptions ()
-    {
-        return NULL;
+
+    void Continue() {
+      type = Type::eContinue;
+      thread = lldb::SBThread();
     }
-    
-    lldb::SBDebugger &
-    GetDebugger()
-    {
-        return m_debugger;
+
+    void StepOver(lldb::SBThread t) {
+      type = Type::eStepOver;
+      thread = t;
     }
 
-    lldb::SBTarget &
-    GetTarget()
-    {
-        return m_target;
+    void StepOut(lldb::SBThread t) {
+      type = Type::eStepOut;
+      thread = t;
     }
-    
-    lldb::SBProcess &
-    GetProcess ()
-    {
-        return m_process;
+
+    void Relaunch(lldb::SBLaunchInfo l) {
+      type = Type::eRelaunch;
+      thread = lldb::SBThread();
+      launch_info = l;
     }
-    
-    lldb::SBThread &
-    GetThread ()
-    {
-        return m_thread;
+
+    void Kill() {
+      type = Type::eKill;
+      thread = lldb::SBThread();
     }
-    
-    int
-    GetStep ()
-    {
-        return m_step;
+
+    void CallNext() {
+      type = Type::eCallNext;
+      thread = lldb::SBThread();
     }
-    
-    static const int RUN_SUCCESS = 0;
-    static const int RUN_SETUP_ERROR = 100;
-    
+  };
+
+  virtual ~TestCase() {}
+
+  virtual bool Setup(int &argc, const char **&argv);
+
+  virtual void TestStep(int counter, ActionWanted &next_action) = 0;
+
+  bool Launch(lldb::SBLaunchInfo &launch_info);
+
+  bool Launch(std::initializer_list<const char *> args = {});
+
+  void Loop();
+
+  void SetVerbose(bool);
+
+  bool GetVerbose();
+
+  virtual void WriteResults(Results &results) = 0;
+
+  template <typename G, typename A>
+  Measurement<G, A> CreateMeasurement(A a, const char *name = NULL,
+                                      const char *description = NULL) {
+    return Measurement<G, A>(a, name, description);
+  }
+
+  template <typename A>
+  TimeMeasurement<A> CreateTimeMeasurement(A a, const char *name = NULL,
+                                           const char *description = NULL) {
+    return TimeMeasurement<A>(a, name, description);
+  }
+
+  template <typename A>
+  MemoryMeasurement<A> CreateMemoryMeasurement(A a, const char *name = NULL,
+                                               const char *description = NULL) {
+    return MemoryMeasurement<A>(a, name, description);
+  }
+
+  static int Run(TestCase &test, int argc, const char **argv);
+
+  virtual bool ParseOption(int short_option, const char *optarg) {
+    return false;
+  }
+
+  virtual struct option *GetLongOptions() { return NULL; }
+
+  lldb::SBDebugger &GetDebugger() { return m_debugger; }
+
+  lldb::SBTarget &GetTarget() { return m_target; }
+
+  lldb::SBProcess &GetProcess() { return m_process; }
+
+  lldb::SBThread &GetThread() { return m_thread; }
+
+  int GetStep() { return m_step; }
+
+  static const int RUN_SUCCESS = 0;
+  static const int RUN_SETUP_ERROR = 100;
+
 protected:
-    lldb::SBDebugger m_debugger;
-	lldb::SBTarget m_target;
-	lldb::SBProcess m_process;
-	lldb::SBThread m_thread;
-	lldb::SBListener m_listener;
-    bool m_verbose;
-    int m_step;
+  lldb::SBDebugger m_debugger;
+  lldb::SBTarget m_target;
+  lldb::SBProcess m_process;
+  lldb::SBThread m_thread;
+  lldb::SBListener m_listener;
+  bool m_verbose;
+  int m_step;
 };
 }
 
diff --git a/lldb/tools/lldb-perf/lib/Timer.cpp b/lldb/tools/lldb-perf/lib/Timer.cpp
index 4bbab90..d221228 100644
--- a/lldb/tools/lldb-perf/lib/Timer.cpp
+++ b/lldb/tools/lldb-perf/lib/Timer.cpp
@@ -12,50 +12,36 @@
 
 using namespace lldb_perf;
 
-TimeGauge::TimeType
-TimeGauge::Now ()
-{
-	return high_resolution_clock::now();
-}
+TimeGauge::TimeType TimeGauge::Now() { return high_resolution_clock::now(); }
 
-TimeGauge::TimeGauge () :
-    m_start(),
-    m_state(TimeGauge::State::eNeverUsed)
-{
-}
+TimeGauge::TimeGauge() : m_start(), m_state(TimeGauge::State::eNeverUsed) {}
 
-void
-TimeGauge::Start ()
-{
-	m_state = TimeGauge::State::eCounting;
-	m_start = Now();
+void TimeGauge::Start() {
+  m_state = TimeGauge::State::eCounting;
+  m_start = Now();
 }
 
-double
-TimeGauge::Stop ()
-{
-	m_stop = Now();
-	assert(m_state == TimeGauge::State::eCounting && "cannot stop a non-started clock");
-	m_state = TimeGauge::State::eStopped;
-    m_delta = duration_cast<duration<double>>(m_stop-m_start).count();
-	return m_delta;
+double TimeGauge::Stop() {
+  m_stop = Now();
+  assert(m_state == TimeGauge::State::eCounting &&
+         "cannot stop a non-started clock");
+  m_state = TimeGauge::State::eStopped;
+  m_delta = duration_cast<duration<double>>(m_stop - m_start).count();
+  return m_delta;
 }
 
-double
-TimeGauge::GetStartValue () const
-{
-    return (double)m_start.time_since_epoch().count() * (double)system_clock::period::num / (double)system_clock::period::den;
+double TimeGauge::GetStartValue() const {
+  return (double)m_start.time_since_epoch().count() *
+         (double)system_clock::period::num / (double)system_clock::period::den;
 }
 
-double
-TimeGauge::GetStopValue () const
-{
-    return (double)m_stop.time_since_epoch().count() * (double)system_clock::period::num / (double)system_clock::period::den;
+double TimeGauge::GetStopValue() const {
+  return (double)m_stop.time_since_epoch().count() *
+         (double)system_clock::period::num / (double)system_clock::period::den;
 }
 
-double
-TimeGauge::GetDeltaValue () const
-{
-	assert(m_state == TimeGauge::State::eStopped && "clock must be used before you can evaluate it");
-	return m_delta;
+double TimeGauge::GetDeltaValue() const {
+  assert(m_state == TimeGauge::State::eStopped &&
+         "clock must be used before you can evaluate it");
+  return m_delta;
 }
diff --git a/lldb/tools/lldb-perf/lib/Timer.h b/lldb/tools/lldb-perf/lib/Timer.h
index ff17935..ddedc2d 100644
--- a/lldb/tools/lldb-perf/lib/Timer.h
+++ b/lldb/tools/lldb-perf/lib/Timer.h
@@ -16,50 +16,33 @@
 
 using namespace std::chrono;
 
-namespace lldb_perf
-{
-class TimeGauge : public Gauge<double>
-{
+namespace lldb_perf {
+class TimeGauge : public Gauge<double> {
 public:
-    TimeGauge ();
-    
-    virtual
-    ~TimeGauge ()
-    {
-    }
-    
-    void
-    Start ();
-    
-    double
-    Stop ();
-    
-    virtual double
-    GetStartValue () const;
-    
-    virtual double
-    GetStopValue () const;
+  TimeGauge();
 
-    virtual double
-    GetDeltaValue () const;
+  virtual ~TimeGauge() {}
+
+  void Start();
+
+  double Stop();
+
+  virtual double GetStartValue() const;
+
+  virtual double GetStopValue() const;
+
+  virtual double GetDeltaValue() const;
 
 private:
-    enum class State
-    {
-        eNeverUsed,
-        eCounting,
-        eStopped
-    };
-    
-    typedef high_resolution_clock::time_point TimeType;
-    TimeType m_start;
-    TimeType m_stop;
-    double m_delta;
-    State m_state;
-    
-    TimeType
-    Now ();
-    
+  enum class State { eNeverUsed, eCounting, eStopped };
+
+  typedef high_resolution_clock::time_point TimeType;
+  TimeType m_start;
+  TimeType m_stop;
+  double m_delta;
+  State m_state;
+
+  TimeType Now();
 };
 }
 
diff --git a/lldb/tools/lldb-perf/lib/Xcode.cpp b/lldb/tools/lldb-perf/lib/Xcode.cpp
index 7b35e1c..c20fb98 100644
--- a/lldb/tools/lldb-perf/lib/Xcode.cpp
+++ b/lldb/tools/lldb-perf/lib/Xcode.cpp
@@ -13,153 +13,125 @@
 using namespace std;
 using namespace lldb_perf;
 
-void
-Xcode::FetchVariable (SBValue value, uint32_t expand, bool verbose)
-{
-	auto name = value.GetName();
-	auto num_value = value.GetValueAsUnsigned(0);
-	auto summary = value.GetSummary();
-	auto in_scope = value.IsInScope();
-	auto has_children = value.MightHaveChildren();
-	auto type_1 = value.GetType();
-	auto type_2 = value.GetType();
-	auto type_name_1 = value.GetTypeName();
-	auto type_3 = value.GetType();
-	auto type_name_2 = value.GetTypeName();
-	if (verbose)
-		printf("%s %s = 0x%llx (%llu) %s\n",value.GetTypeName(),value.GetName(),num_value, num_value,summary);
-	if (expand > 0)
-	{
-		auto count = value.GetNumChildren();
-		for (int i = 0; i < count; i++)
-		{
-			SBValue child(value.GetChildAtIndex(i, lldb::eDynamicCanRunTarget, true));
-			FetchVariable (child,expand-1,verbose);
-		}
-	}
+void Xcode::FetchVariable(SBValue value, uint32_t expand, bool verbose) {
+  auto name = value.GetName();
+  auto num_value = value.GetValueAsUnsigned(0);
+  auto summary = value.GetSummary();
+  auto in_scope = value.IsInScope();
+  auto has_children = value.MightHaveChildren();
+  auto type_1 = value.GetType();
+  auto type_2 = value.GetType();
+  auto type_name_1 = value.GetTypeName();
+  auto type_3 = value.GetType();
+  auto type_name_2 = value.GetTypeName();
+  if (verbose)
+    printf("%s %s = 0x%llx (%llu) %s\n", value.GetTypeName(), value.GetName(),
+           num_value, num_value, summary);
+  if (expand > 0) {
+    auto count = value.GetNumChildren();
+    for (int i = 0; i < count; i++) {
+      SBValue child(value.GetChildAtIndex(i, lldb::eDynamicCanRunTarget, true));
+      FetchVariable(child, expand - 1, verbose);
+    }
+  }
 }
 
-void
-Xcode::FetchModules (SBTarget target, bool verbose)
-{
-	auto count = target.GetNumModules();
-	for (int i = 0; i < count; i++)
-	{
-		SBModule module(target.GetModuleAtIndex(i));
-		auto fspec = module.GetFileSpec();
-		std::string path(1024,0);
-		fspec.GetPath(&path[0],1024);
-		auto uuid = module.GetUUIDBytes();
-		if (verbose)
-		{
-			printf("%s %s\n",path.c_str(),module.GetUUIDString());
-		}
-	}
+void Xcode::FetchModules(SBTarget target, bool verbose) {
+  auto count = target.GetNumModules();
+  for (int i = 0; i < count; i++) {
+    SBModule module(target.GetModuleAtIndex(i));
+    auto fspec = module.GetFileSpec();
+    std::string path(1024, 0);
+    fspec.GetPath(&path[0], 1024);
+    auto uuid = module.GetUUIDBytes();
+    if (verbose) {
+      printf("%s %s\n", path.c_str(), module.GetUUIDString());
+    }
+  }
 }
 
-void
-Xcode::FetchVariables (SBFrame frame, uint32_t expand, bool verbose)
-{
-	auto values = frame.GetVariables (true,true,true,false, eDynamicCanRunTarget);
-	auto count = values.GetSize();
-	for (int i = 0; i < count; i++)
-	{
-		SBValue value(values.GetValueAtIndex(i));
-		FetchVariable (value,expand,verbose);
-	}
+void Xcode::FetchVariables(SBFrame frame, uint32_t expand, bool verbose) {
+  auto values =
+      frame.GetVariables(true, true, true, false, eDynamicCanRunTarget);
+  auto count = values.GetSize();
+  for (int i = 0; i < count; i++) {
+    SBValue value(values.GetValueAtIndex(i));
+    FetchVariable(value, expand, verbose);
+  }
 }
 
-void
-Xcode::FetchFrames(SBProcess process, bool variables, bool verbose)
-{
-	auto pCount = process.GetNumThreads();
-	for (int p = 0; p < pCount; p++)
-	{
-		SBThread thread(process.GetThreadAtIndex(p));
-		auto tCount = thread.GetNumFrames ();
-		if (verbose)
-			printf("%s %d %d {%d}\n",thread.GetQueueName(),tCount,thread.GetStopReason(),eStopReasonBreakpoint);
-		for (int t = 0; t < tCount; t++)
-		{
-			SBFrame frame(thread.GetFrameAtIndex(t));
-			auto fp = frame.GetFP();
-			SBThread thread_dup = frame.GetThread();
-			SBFileSpec filespec(process.GetTarget().GetExecutable());
-			std::string path(1024,0);
-			filespec.GetPath(&path[0],1024);
-			auto state = process.GetState();
-			auto pCount_dup = process.GetNumThreads();
-			auto byte_size = process.GetAddressByteSize();
-			auto pc = frame.GetPC();
-			SBSymbolContext context(frame.GetSymbolContext(0x0000006e));
-			SBModule module(context.GetModule());
-			SBLineEntry entry(context.GetLineEntry());
-			SBFileSpec entry_filespec(process.GetTarget().GetExecutable());
-			std::string entry_path(1024,0);
-			entry_filespec.GetPath(&entry_path[0],1024);
-			auto line_1 = entry.GetLine();
-			auto line_2 = entry.GetLine();
-			auto fname = frame.GetFunctionName();
-			if (verbose)
-				printf("%llu %s %d %d %llu %s %d %s\n",fp,path.c_str(),state,byte_size,pc,entry_path.c_str(),line_1,fname);
-			if (variables)
-				FetchVariables (frame, 0, verbose);
-		}
-	}
+void Xcode::FetchFrames(SBProcess process, bool variables, bool verbose) {
+  auto pCount = process.GetNumThreads();
+  for (int p = 0; p < pCount; p++) {
+    SBThread thread(process.GetThreadAtIndex(p));
+    auto tCount = thread.GetNumFrames();
+    if (verbose)
+      printf("%s %d %d {%d}\n", thread.GetQueueName(), tCount,
+             thread.GetStopReason(), eStopReasonBreakpoint);
+    for (int t = 0; t < tCount; t++) {
+      SBFrame frame(thread.GetFrameAtIndex(t));
+      auto fp = frame.GetFP();
+      SBThread thread_dup = frame.GetThread();
+      SBFileSpec filespec(process.GetTarget().GetExecutable());
+      std::string path(1024, 0);
+      filespec.GetPath(&path[0], 1024);
+      auto state = process.GetState();
+      auto pCount_dup = process.GetNumThreads();
+      auto byte_size = process.GetAddressByteSize();
+      auto pc = frame.GetPC();
+      SBSymbolContext context(frame.GetSymbolContext(0x0000006e));
+      SBModule module(context.GetModule());
+      SBLineEntry entry(context.GetLineEntry());
+      SBFileSpec entry_filespec(process.GetTarget().GetExecutable());
+      std::string entry_path(1024, 0);
+      entry_filespec.GetPath(&entry_path[0], 1024);
+      auto line_1 = entry.GetLine();
+      auto line_2 = entry.GetLine();
+      auto fname = frame.GetFunctionName();
+      if (verbose)
+        printf("%llu %s %d %d %llu %s %d %s\n", fp, path.c_str(), state,
+               byte_size, pc, entry_path.c_str(), line_1, fname);
+      if (variables)
+        FetchVariables(frame, 0, verbose);
+    }
+  }
 }
 
-void
-Xcode::RunExpression (SBFrame frame, const char* expression, bool po, bool verbose)
-{
-	SBValue value (frame.EvaluateExpression (expression, eDynamicCanRunTarget));
-	FetchVariable (value,0,verbose);
-	if (po)
-	{
-		auto descr = value.GetObjectDescription();
-		if (descr)
-			printf("po = %s\n",descr);
-	}
+void Xcode::RunExpression(SBFrame frame, const char *expression, bool po,
+                          bool verbose) {
+  SBValue value(frame.EvaluateExpression(expression, eDynamicCanRunTarget));
+  FetchVariable(value, 0, verbose);
+  if (po) {
+    auto descr = value.GetObjectDescription();
+    if (descr)
+      printf("po = %s\n", descr);
+  }
 }
 
-void
-Xcode::Next (SBThread thread)
-{
-	thread.StepOver();
-}
+void Xcode::Next(SBThread thread) { thread.StepOver(); }
 
-void
-Xcode::Continue (SBProcess process)
-{
-	process.Continue();
-}
+void Xcode::Continue(SBProcess process) { process.Continue(); }
 
-void
-Xcode::RunCommand (SBDebugger debugger, const char* cmd, bool verbose)
-{
-	SBCommandReturnObject sb_ret;
-	auto interpreter = debugger.GetCommandInterpreter();
-	interpreter.HandleCommand(cmd,sb_ret);
-	if (verbose)
-		printf("%s\n%s\n",sb_ret.GetOutput(false),sb_ret.GetError(false));
+void Xcode::RunCommand(SBDebugger debugger, const char *cmd, bool verbose) {
+  SBCommandReturnObject sb_ret;
+  auto interpreter = debugger.GetCommandInterpreter();
+  interpreter.HandleCommand(cmd, sb_ret);
+  if (verbose)
+    printf("%s\n%s\n", sb_ret.GetOutput(false), sb_ret.GetError(false));
 }
 
-SBThread
-Xcode::GetThreadWithStopReason (SBProcess process, StopReason reason)
-{
-	auto threads_count = process.GetNumThreads();
-	for (auto thread_num = 0; thread_num < threads_count; thread_num++)
-	{
-		SBThread thread(process.GetThreadAtIndex(thread_num));
-		if (thread.GetStopReason() == reason)
-		{
-			return thread;
-		}
-	}
-	return SBThread();
+SBThread Xcode::GetThreadWithStopReason(SBProcess process, StopReason reason) {
+  auto threads_count = process.GetNumThreads();
+  for (auto thread_num = 0; thread_num < threads_count; thread_num++) {
+    SBThread thread(process.GetThreadAtIndex(thread_num));
+    if (thread.GetStopReason() == reason) {
+      return thread;
+    }
+  }
+  return SBThread();
 }
 
-SBBreakpoint
-Xcode::CreateFileLineBreakpoint (SBTarget target, const char* file, uint32_t line)
-{
-    return target.BreakpointCreateByLocation(file, line);
+SBBreakpoint Xcode::CreateFileLineBreakpoint(SBTarget target, const char *file,
+                                             uint32_t line) {
+  return target.BreakpointCreateByLocation(file, line);
 }
diff --git a/lldb/tools/lldb-perf/lib/Xcode.h b/lldb/tools/lldb-perf/lib/Xcode.h
index 77e0253..41f58dc 100644
--- a/lldb/tools/lldb-perf/lib/Xcode.h
+++ b/lldb/tools/lldb-perf/lib/Xcode.h
@@ -10,54 +10,48 @@
 #ifndef __PerfTestDriver__Xcode__
 #define __PerfTestDriver__Xcode__
 
+#include "lldb/API/SBBreakpoint.h"
+#include "lldb/API/SBCommandInterpreter.h"
+#include "lldb/API/SBCommandReturnObject.h"
+#include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBDefines.h"
-#include "lldb/API/SBValue.h"
-#include "lldb/API/SBTarget.h"
+#include "lldb/API/SBLineEntry.h"
 #include "lldb/API/SBModule.h"
 #include "lldb/API/SBProcess.h"
-#include "lldb/API/SBLineEntry.h"
+#include "lldb/API/SBTarget.h"
 #include "lldb/API/SBThread.h"
-#include "lldb/API/SBDebugger.h"
-#include "lldb/API/SBCommandInterpreter.h"
-#include "lldb/API/SBCommandReturnObject.h"
-#include "lldb/API/SBBreakpoint.h"
+#include "lldb/API/SBValue.h"
 
 using namespace lldb;
 
-namespace lldb_perf
-{
-class Xcode
-{
+namespace lldb_perf {
+class Xcode {
 public:
-	static void
-	FetchVariable (SBValue value, uint32_t expand = 0, bool verbose = false);
-    
-	static void
-	FetchModules (SBTarget target, bool verbose = false);
-    
-	static void
-	FetchVariables (SBFrame frame, uint32_t expand = 0, bool verbose = false);
-    
-	static void
-	FetchFrames (SBProcess process, bool variables = false, bool verbose = false);
-	
-	static void
-	RunExpression (SBFrame frame, const char* expression, bool po = false, bool verbose = false);
-	
-	static void
-	Next (SBThread thread);
-	
-	static void
-	Continue (SBProcess process);
-	
-	static void
-	RunCommand (SBDebugger debugger, const char* cmd, bool verbose = false);
-	
-	static SBThread
-	GetThreadWithStopReason (SBProcess process, StopReason reason);
-    
-    static SBBreakpoint
-    CreateFileLineBreakpoint (SBTarget target, const char* file, uint32_t line);
+  static void FetchVariable(SBValue value, uint32_t expand = 0,
+                            bool verbose = false);
+
+  static void FetchModules(SBTarget target, bool verbose = false);
+
+  static void FetchVariables(SBFrame frame, uint32_t expand = 0,
+                             bool verbose = false);
+
+  static void FetchFrames(SBProcess process, bool variables = false,
+                          bool verbose = false);
+
+  static void RunExpression(SBFrame frame, const char *expression,
+                            bool po = false, bool verbose = false);
+
+  static void Next(SBThread thread);
+
+  static void Continue(SBProcess process);
+
+  static void RunCommand(SBDebugger debugger, const char *cmd,
+                         bool verbose = false);
+
+  static SBThread GetThreadWithStopReason(SBProcess process, StopReason reason);
+
+  static SBBreakpoint CreateFileLineBreakpoint(SBTarget target,
+                                               const char *file, uint32_t line);
 };
 }