Imported Upstream version 6.10.0.49

Former-commit-id: 1d6753294b2993e1fbf92de9366bb9544db4189b

external/llvm-project/lldb/tools/lldb-perf/common/clang/build-clang.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+
+if [ -d "llvm-build" ]; then
+    echo "Using existing 'llvm-build' directory..."    
+else
+    mkdir llvm-build
+fi
+
+cd llvm-build
+
+if [ -d "llvm" ]; then
+    echo "Using existing 'llvm' directory..."
+else
+    svn co --revision 176809 http://llvm.org/svn/llvm-project/llvm/trunk llvm
+    ( cd llvm/tools ; svn co --revision 176809 http://llvm.org/svn/llvm-project/cfe/trunk clang )
+fi
+
+if [ ! -d "build" ]; then
+    mkdir build
+    cd build
+    ../llvm/configure --enable-targets=x86_64,arm --build=x86_64-apple-darwin10 --disable-optimized --disable-assertions --enable-libcpp
+    make -j8 clang-only DEBUG_SYMBOLS=1
+    rm -rf lib projects runtime unittests utils config.*
+    ( cd ./Debug/bin ; rm -rf ll* clang-check clang-tblgen count diagtool fpcmp macho-dump not opt yaml2obj FileCheck FileUpdate arcmt-test c-arcmt-test c-index-test bugpoint )
+    ( cd ./tools ; rm -rf ll* clang-check clang-tblgen count diagtool fpcmp lto macho-dump not opt yaml2obj FileCheck FileUpdate arcmt-test c-arcmt-test c-index-test bugpoint )
+    ( cd ./tools/clang ; rm -rf lib unittests utils )
+    ( cd ./tools/clang/tools ; rm -rf arcmt-test c-arcmt-test c-index-test clang-check diagtool libclang )
+    ( cd ../llvm ; rm -rf cmake configure docs examples projects *.txt *.TXT autoconf bindings test unittests utils ; find . -type d -name .svn -print0 | xargs -0 rm -rf )
+    ( cd ../llvm/tools ; rm -rf *.txt bugpoint bugpoint-passes ll* lto macho-dump opt gold )
+fi
+
+
+

external/llvm-project/lldb/tools/lldb-perf/common/clang/lldb_perf_clang.cpp

@@ -0,0 +1,442 @@
+//===-- lldb_perf_clang.cpp -------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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 <fstream>
+#include <getopt.h>
+#include <iostream>
+#include <unistd.h>
+
+using namespace lldb_perf;
+
+#define NUM_EXPR_ITERATIONS 3
+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 <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);
+    }
+}
+                        
+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;
+}
+)";
+        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; }
+
+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;
+};
+
+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) {}
+};
+
+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;
+      }
+    }
+  }
+  return option_string;
+}
+
+int main(int argc, const char *argv[]) {
+
+  // Prepare for & make calls to getopt_long_only.
+
+  std::string short_option_string(GetShortOptionString(g_long_options));
+
+  ClangTest test;
+
+  Options option_data;
+  bool done = false;
+
+#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(),
+        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 (option_data.print_help) {
+    puts(R"(
+NAME
+    lldb_perf_clang -- a tool that measures LLDB peformance while debugging clang.
+
+SYNOPSIS
+    lldb_perf_clang --clang=PATH [--out-file=PATH --verbose --dsym] -- [clang options]
+             
+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;
+}

external/llvm-project/lldb/tools/lldb-perf/common/clang/main.cpp

@@ -0,0 +1,20 @@
+#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); }
+}
+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;
+}

external/llvm-project/lldb/tools/lldb-perf/common/stepping/lldb-perf-stepping.cpp

@@ -0,0 +1,287 @@
+#include <CoreFoundation/CoreFoundation.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 <getopt.h>
+#include <string>
+#include <unistd.h>
+
+using namespace lldb_perf;
+
+class StepTest : public TestCase {
+  typedef void (*no_function)(void);
+
+public:
+  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);
+  }
+
+  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();
+  }
+
+  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) {}
+};
+
+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;
+}
+
+int main(int argc, const char *argv[]) {
+
+  // Prepare for & make calls to getopt_long_only.
+
+  std::string short_option_string(GetShortOptionString(g_long_options));
+
+  StepTest test;
+
+  Options option_data;
+  bool done = false;
+
+#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(),
+        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"(
+NAME
+    lldb-perf-stepping -- a tool that measures LLDB peformance of simple stepping operations.
+
+SYNOPSIS
+    lldb-perf-stepping --test-file=FILE [--out-file=PATH --verbose --fast-step]
+             
+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;
+}

external/llvm-project/lldb/tools/lldb-perf/common/stepping/stepping-testcase.cpp

@@ -0,0 +1,35 @@
+#include <stdio.h>
+#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, ""); }
+
+  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;
+}