b9c1b51e45
*** 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
309 lines
9.0 KiB
C++
309 lines
9.0 KiB
C++
//===-- TestCase.cpp --------------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "TestCase.h"
|
|
#include "Results.h"
|
|
#include "Xcode.h"
|
|
|
|
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);
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
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);
|
|
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("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;
|
|
}
|
|
}
|
|
} 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 (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;
|
|
}
|