forked from OSchip/llvm-project
Finish the reformatting of the lldb-server test executables
This also reformats the executables in subfolders of lldb-server tests. llvm-svn: 295952
This commit is contained in:
Pavel Labath
parent
7337212e83
commit
c7ce4fef20
|
|
@ -15,22 +15,22 @@
|
|||
|
||||
#if defined(__APPLE__)
|
||||
__OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2)
|
||||
int pthread_threadid_np(pthread_t,__uint64_t*);
|
||||
int pthread_threadid_np(pthread_t, __uint64_t *);
|
||||
#elif defined(__linux__)
|
||||
#include <sys/syscall.h>
|
||||
#endif
|
||||
|
||||
static const char *const RETVAL_PREFIX = "retval:";
|
||||
static const char *const SLEEP_PREFIX = "sleep:";
|
||||
static const char *const STDERR_PREFIX = "stderr:";
|
||||
static const char *const SET_MESSAGE_PREFIX = "set-message:";
|
||||
static const char *const PRINT_MESSAGE_COMMAND = "print-message:";
|
||||
static const char *const GET_DATA_ADDRESS_PREFIX = "get-data-address-hex:";
|
||||
static const char *const GET_STACK_ADDRESS_COMMAND = "get-stack-address-hex:";
|
||||
static const char *const GET_HEAP_ADDRESS_COMMAND = "get-heap-address-hex:";
|
||||
static const char *const RETVAL_PREFIX = "retval:";
|
||||
static const char *const SLEEP_PREFIX = "sleep:";
|
||||
static const char *const STDERR_PREFIX = "stderr:";
|
||||
static const char *const SET_MESSAGE_PREFIX = "set-message:";
|
||||
static const char *const PRINT_MESSAGE_COMMAND = "print-message:";
|
||||
static const char *const GET_DATA_ADDRESS_PREFIX = "get-data-address-hex:";
|
||||
static const char *const GET_STACK_ADDRESS_COMMAND = "get-stack-address-hex:";
|
||||
static const char *const GET_HEAP_ADDRESS_COMMAND = "get-heap-address-hex:";
|
||||
|
||||
static const char *const GET_CODE_ADDRESS_PREFIX = "get-code-address-hex:";
|
||||
static const char *const CALL_FUNCTION_PREFIX = "call-function:";
|
||||
static const char *const GET_CODE_ADDRESS_PREFIX = "get-code-address-hex:";
|
||||
static const char *const CALL_FUNCTION_PREFIX = "call-function:";
|
||||
|
||||
static const char *const THREAD_PREFIX = "thread:";
|
||||
static const char *const THREAD_COMMAND_NEW = "new";
|
||||
|
|
@ -50,342 +50,301 @@ static char g_message[256];
|
|||
static volatile char g_c1 = '0';
|
||||
static volatile char g_c2 = '1';
|
||||
|
||||
static void
|
||||
print_thread_id ()
|
||||
{
|
||||
// Put in the right magic here for your platform to spit out the thread id (tid) that debugserver/lldb-gdbserver would see as a TID.
|
||||
// Otherwise, let the else clause print out the unsupported text so that the unit test knows to skip verifying thread ids.
|
||||
static void print_thread_id() {
|
||||
// Put in the right magic here for your platform to spit out the thread id (tid)
|
||||
// that debugserver/lldb-gdbserver would see as a TID. Otherwise, let the else
|
||||
// clause print out the unsupported text so that the unit test knows to skip
|
||||
// verifying thread ids.
|
||||
#if defined(__APPLE__)
|
||||
__uint64_t tid = 0;
|
||||
pthread_threadid_np(pthread_self(), &tid);
|
||||
printf ("%" PRIx64, tid);
|
||||
#elif defined (__linux__)
|
||||
// This is a call to gettid() via syscall.
|
||||
printf ("%" PRIx64, static_cast<uint64_t> (syscall (__NR_gettid)));
|
||||
__uint64_t tid = 0;
|
||||
pthread_threadid_np(pthread_self(), &tid);
|
||||
printf("%" PRIx64, tid);
|
||||
#elif defined(__linux__)
|
||||
// This is a call to gettid() via syscall.
|
||||
printf("%" PRIx64, static_cast<uint64_t>(syscall(__NR_gettid)));
|
||||
#else
|
||||
printf("{no-tid-support}");
|
||||
printf("{no-tid-support}");
|
||||
#endif
|
||||
}
|
||||
|
||||
static void
|
||||
signal_handler (int signo)
|
||||
{
|
||||
const char *signal_name = nullptr;
|
||||
switch (signo)
|
||||
{
|
||||
case SIGUSR1: signal_name = "SIGUSR1"; break;
|
||||
case SIGSEGV: signal_name = "SIGSEGV"; break;
|
||||
default: signal_name = nullptr;
|
||||
}
|
||||
static void signal_handler(int signo) {
|
||||
const char *signal_name = nullptr;
|
||||
switch (signo) {
|
||||
case SIGUSR1:
|
||||
signal_name = "SIGUSR1";
|
||||
break;
|
||||
case SIGSEGV:
|
||||
signal_name = "SIGSEGV";
|
||||
break;
|
||||
default:
|
||||
signal_name = nullptr;
|
||||
}
|
||||
|
||||
// Print notice that we received the signal on a given thread.
|
||||
pthread_mutex_lock (&g_print_mutex);
|
||||
if (signal_name)
|
||||
printf ("received %s on thread id: ", signal_name);
|
||||
else
|
||||
printf ("received signo %d (%s) on thread id: ", signo, strsignal (signo));
|
||||
print_thread_id ();
|
||||
printf ("\n");
|
||||
pthread_mutex_unlock (&g_print_mutex);
|
||||
// Print notice that we received the signal on a given thread.
|
||||
pthread_mutex_lock(&g_print_mutex);
|
||||
if (signal_name)
|
||||
printf("received %s on thread id: ", signal_name);
|
||||
else
|
||||
printf("received signo %d (%s) on thread id: ", signo, strsignal(signo));
|
||||
print_thread_id();
|
||||
printf("\n");
|
||||
pthread_mutex_unlock(&g_print_mutex);
|
||||
|
||||
// Reset the signal handler if we're one of the expected signal handlers.
|
||||
switch (signo)
|
||||
{
|
||||
case SIGSEGV:
|
||||
if (g_is_segfaulting)
|
||||
{
|
||||
// Fix up the pointer we're writing to. This needs to happen if nothing intercepts the SIGSEGV
|
||||
// (i.e. if somebody runs this from the command line).
|
||||
longjmp(g_jump_buffer, 1);
|
||||
}
|
||||
break;
|
||||
case SIGUSR1:
|
||||
if (g_is_segfaulting)
|
||||
{
|
||||
// Fix up the pointer we're writing to. This is used to test gdb remote signal delivery.
|
||||
// A SIGSEGV will be raised when the thread is created, switched out for a SIGUSR1, and
|
||||
// then this code still needs to fix the seg fault.
|
||||
// (i.e. if somebody runs this from the command line).
|
||||
longjmp(g_jump_buffer, 1);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
// Reset the signal handler.
|
||||
sig_t sig_result = signal (signo, signal_handler);
|
||||
if (sig_result == SIG_ERR)
|
||||
{
|
||||
fprintf(stderr, "failed to set signal handler: errno=%d\n", errno);
|
||||
exit (1);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
swap_chars ()
|
||||
{
|
||||
g_c1 = '1';
|
||||
g_c2 = '0';
|
||||
|
||||
g_c1 = '0';
|
||||
g_c2 = '1';
|
||||
}
|
||||
|
||||
static void
|
||||
hello ()
|
||||
{
|
||||
pthread_mutex_lock (&g_print_mutex);
|
||||
printf ("hello, world\n");
|
||||
pthread_mutex_unlock (&g_print_mutex);
|
||||
}
|
||||
|
||||
static void*
|
||||
thread_func (void *arg)
|
||||
{
|
||||
static pthread_mutex_t s_thread_index_mutex = PTHREAD_MUTEX_INITIALIZER;
|
||||
static int s_thread_index = 1;
|
||||
|
||||
pthread_mutex_lock (&s_thread_index_mutex);
|
||||
const int this_thread_index = s_thread_index++;
|
||||
pthread_mutex_unlock (&s_thread_index_mutex);
|
||||
|
||||
if (g_print_thread_ids)
|
||||
{
|
||||
pthread_mutex_lock (&g_print_mutex);
|
||||
printf ("thread %d id: ", this_thread_index);
|
||||
print_thread_id ();
|
||||
printf ("\n");
|
||||
pthread_mutex_unlock (&g_print_mutex);
|
||||
}
|
||||
|
||||
if (g_threads_do_segfault)
|
||||
{
|
||||
// Sleep for a number of seconds based on the thread index.
|
||||
// TODO add ability to send commands to test exe so we can
|
||||
// handle timing more precisely. This is clunky. All we're
|
||||
// trying to do is add predictability as to the timing of
|
||||
// signal generation by created threads.
|
||||
int sleep_seconds = 2 * (this_thread_index - 1);
|
||||
while (sleep_seconds > 0)
|
||||
sleep_seconds = sleep(sleep_seconds);
|
||||
|
||||
// Test creating a SEGV.
|
||||
pthread_mutex_lock (&g_jump_buffer_mutex);
|
||||
g_is_segfaulting = true;
|
||||
int *bad_p = nullptr;
|
||||
if (setjmp(g_jump_buffer) == 0)
|
||||
{
|
||||
// Force a seg fault signal on this thread.
|
||||
*bad_p = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Tell the system we're no longer seg faulting.
|
||||
// Used by the SIGUSR1 signal handler that we inject
|
||||
// in place of the SIGSEGV so it only tries to
|
||||
// recover from the SIGSEGV if this seg fault code
|
||||
// was in play.
|
||||
g_is_segfaulting = false;
|
||||
}
|
||||
pthread_mutex_unlock (&g_jump_buffer_mutex);
|
||||
|
||||
pthread_mutex_lock (&g_print_mutex);
|
||||
printf ("thread ");
|
||||
print_thread_id ();
|
||||
printf (": past SIGSEGV\n");
|
||||
pthread_mutex_unlock (&g_print_mutex);
|
||||
}
|
||||
|
||||
int sleep_seconds_remaining = 60;
|
||||
while (sleep_seconds_remaining > 0)
|
||||
{
|
||||
sleep_seconds_remaining = sleep (sleep_seconds_remaining);
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
int main (int argc, char **argv)
|
||||
{
|
||||
lldb_enable_attach();
|
||||
|
||||
std::vector<pthread_t> threads;
|
||||
std::unique_ptr<uint8_t[]> heap_array_up;
|
||||
int return_value = 0;
|
||||
|
||||
// Set the signal handler.
|
||||
sig_t sig_result = signal (SIGALRM, signal_handler);
|
||||
if (sig_result == SIG_ERR)
|
||||
{
|
||||
fprintf(stderr, "failed to set SIGALRM signal handler: errno=%d\n", errno);
|
||||
exit (1);
|
||||
}
|
||||
|
||||
sig_result = signal (SIGUSR1, signal_handler);
|
||||
if (sig_result == SIG_ERR)
|
||||
{
|
||||
fprintf(stderr, "failed to set SIGUSR1 handler: errno=%d\n", errno);
|
||||
exit (1);
|
||||
}
|
||||
|
||||
sig_result = signal (SIGSEGV, signal_handler);
|
||||
if (sig_result == SIG_ERR)
|
||||
{
|
||||
fprintf(stderr, "failed to set SIGUSR1 handler: errno=%d\n", errno);
|
||||
exit (1);
|
||||
}
|
||||
|
||||
// Process command line args.
|
||||
for (int i = 1; i < argc; ++i)
|
||||
{
|
||||
if (std::strstr (argv[i], STDERR_PREFIX))
|
||||
{
|
||||
// Treat remainder as text to go to stderr.
|
||||
fprintf (stderr, "%s\n", (argv[i] + strlen (STDERR_PREFIX)));
|
||||
}
|
||||
else if (std::strstr (argv[i], RETVAL_PREFIX))
|
||||
{
|
||||
// Treat as the return value for the program.
|
||||
return_value = std::atoi (argv[i] + strlen (RETVAL_PREFIX));
|
||||
}
|
||||
else if (std::strstr (argv[i], SLEEP_PREFIX))
|
||||
{
|
||||
// Treat as the amount of time to have this process sleep (in seconds).
|
||||
int sleep_seconds_remaining = std::atoi (argv[i] + strlen (SLEEP_PREFIX));
|
||||
|
||||
// Loop around, sleeping until all sleep time is used up. Note that
|
||||
// signals will cause sleep to end early with the number of seconds remaining.
|
||||
for (int i = 0; sleep_seconds_remaining > 0; ++i)
|
||||
{
|
||||
sleep_seconds_remaining = sleep (sleep_seconds_remaining);
|
||||
// std::cout << "sleep result (call " << i << "): " << sleep_seconds_remaining << std::endl;
|
||||
}
|
||||
}
|
||||
else if (std::strstr (argv[i], SET_MESSAGE_PREFIX))
|
||||
{
|
||||
// Copy the contents after "set-message:" to the g_message buffer.
|
||||
// Used for reading inferior memory and verifying contents match expectations.
|
||||
strncpy (g_message, argv[i] + strlen (SET_MESSAGE_PREFIX), sizeof (g_message));
|
||||
|
||||
// Ensure we're null terminated.
|
||||
g_message[sizeof (g_message) - 1] = '\0';
|
||||
|
||||
}
|
||||
else if (std::strstr (argv[i], PRINT_MESSAGE_COMMAND))
|
||||
{
|
||||
pthread_mutex_lock (&g_print_mutex);
|
||||
printf ("message: %s\n", g_message);
|
||||
pthread_mutex_unlock (&g_print_mutex);
|
||||
}
|
||||
else if (std::strstr (argv[i], GET_DATA_ADDRESS_PREFIX))
|
||||
{
|
||||
volatile void *data_p = nullptr;
|
||||
|
||||
if (std::strstr (argv[i] + strlen (GET_DATA_ADDRESS_PREFIX), "g_message"))
|
||||
data_p = &g_message[0];
|
||||
else if (std::strstr (argv[i] + strlen (GET_DATA_ADDRESS_PREFIX), "g_c1"))
|
||||
data_p = &g_c1;
|
||||
else if (std::strstr (argv[i] + strlen (GET_DATA_ADDRESS_PREFIX), "g_c2"))
|
||||
data_p = &g_c2;
|
||||
|
||||
pthread_mutex_lock (&g_print_mutex);
|
||||
printf ("data address: %p\n", data_p);
|
||||
pthread_mutex_unlock (&g_print_mutex);
|
||||
}
|
||||
else if (std::strstr (argv[i], GET_HEAP_ADDRESS_COMMAND))
|
||||
{
|
||||
// Create a byte array if not already present.
|
||||
if (!heap_array_up)
|
||||
heap_array_up.reset (new uint8_t[32]);
|
||||
|
||||
pthread_mutex_lock (&g_print_mutex);
|
||||
printf ("heap address: %p\n", heap_array_up.get ());
|
||||
pthread_mutex_unlock (&g_print_mutex);
|
||||
}
|
||||
else if (std::strstr (argv[i], GET_STACK_ADDRESS_COMMAND))
|
||||
{
|
||||
pthread_mutex_lock (&g_print_mutex);
|
||||
printf ("stack address: %p\n", &return_value);
|
||||
pthread_mutex_unlock (&g_print_mutex);
|
||||
}
|
||||
else if (std::strstr (argv[i], GET_CODE_ADDRESS_PREFIX))
|
||||
{
|
||||
void (*func_p)() = nullptr;
|
||||
|
||||
if (std::strstr (argv[i] + strlen (GET_CODE_ADDRESS_PREFIX), "hello"))
|
||||
func_p = hello;
|
||||
else if (std::strstr (argv[i] + strlen (GET_CODE_ADDRESS_PREFIX), "swap_chars"))
|
||||
func_p = swap_chars;
|
||||
|
||||
pthread_mutex_lock (&g_print_mutex);
|
||||
printf ("code address: %p\n", func_p);
|
||||
pthread_mutex_unlock (&g_print_mutex);
|
||||
}
|
||||
else if (std::strstr (argv[i], CALL_FUNCTION_PREFIX))
|
||||
{
|
||||
// Defaut to providing the address of main.
|
||||
if (std::strcmp (argv[i] + strlen (CALL_FUNCTION_PREFIX), "hello") == 0)
|
||||
hello();
|
||||
else if (std::strcmp (argv[i] + strlen (CALL_FUNCTION_PREFIX), "swap_chars") == 0)
|
||||
swap_chars();
|
||||
else
|
||||
{
|
||||
pthread_mutex_lock (&g_print_mutex);
|
||||
printf ("unknown function: %s\n", argv[i] + strlen (CALL_FUNCTION_PREFIX));
|
||||
pthread_mutex_unlock (&g_print_mutex);
|
||||
}
|
||||
}
|
||||
else if (std::strstr (argv[i], THREAD_PREFIX))
|
||||
{
|
||||
// Check if we're creating a new thread.
|
||||
if (std::strstr (argv[i] + strlen(THREAD_PREFIX), THREAD_COMMAND_NEW))
|
||||
{
|
||||
// Create a new thread.
|
||||
pthread_t new_thread;
|
||||
const int err = ::pthread_create (&new_thread, nullptr, thread_func, nullptr);
|
||||
if (err)
|
||||
{
|
||||
fprintf (stderr, "pthread_create() failed with error code %d\n", err);
|
||||
exit (err);
|
||||
}
|
||||
threads.push_back (new_thread);
|
||||
}
|
||||
else if (std::strstr (argv[i] + strlen(THREAD_PREFIX), THREAD_COMMAND_PRINT_IDS))
|
||||
{
|
||||
// Turn on thread id announcing.
|
||||
g_print_thread_ids = true;
|
||||
|
||||
// And announce us.
|
||||
pthread_mutex_lock (&g_print_mutex);
|
||||
printf ("thread 0 id: ");
|
||||
print_thread_id ();
|
||||
printf ("\n");
|
||||
pthread_mutex_unlock (&g_print_mutex);
|
||||
}
|
||||
else if (std::strstr (argv[i] + strlen(THREAD_PREFIX), THREAD_COMMAND_SEGFAULT))
|
||||
{
|
||||
g_threads_do_segfault = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
// At this point we don't do anything else with threads.
|
||||
// Later use thread index and send command to thread.
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// Treat the argument as text for stdout.
|
||||
printf("%s\n", argv[i]);
|
||||
}
|
||||
// Reset the signal handler if we're one of the expected signal handlers.
|
||||
switch (signo) {
|
||||
case SIGSEGV:
|
||||
if (g_is_segfaulting) {
|
||||
// Fix up the pointer we're writing to. This needs to happen if nothing
|
||||
// intercepts the SIGSEGV (i.e. if somebody runs this from the command
|
||||
// line).
|
||||
longjmp(g_jump_buffer, 1);
|
||||
}
|
||||
break;
|
||||
case SIGUSR1:
|
||||
if (g_is_segfaulting) {
|
||||
// Fix up the pointer we're writing to. This is used to test gdb remote
|
||||
// signal delivery. A SIGSEGV will be raised when the thread is created,
|
||||
// switched out for a SIGUSR1, and then this code still needs to fix the
|
||||
// seg fault. (i.e. if somebody runs this from the command line).
|
||||
longjmp(g_jump_buffer, 1);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
// If we launched any threads, join them
|
||||
for (std::vector<pthread_t>::iterator it = threads.begin (); it != threads.end (); ++it)
|
||||
{
|
||||
void *thread_retval = nullptr;
|
||||
const int err = ::pthread_join (*it, &thread_retval);
|
||||
if (err != 0)
|
||||
fprintf (stderr, "pthread_join() failed with error code %d\n", err);
|
||||
}
|
||||
|
||||
return return_value;
|
||||
// Reset the signal handler.
|
||||
sig_t sig_result = signal(signo, signal_handler);
|
||||
if (sig_result == SIG_ERR) {
|
||||
fprintf(stderr, "failed to set signal handler: errno=%d\n", errno);
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
static void swap_chars() {
|
||||
g_c1 = '1';
|
||||
g_c2 = '0';
|
||||
|
||||
g_c1 = '0';
|
||||
g_c2 = '1';
|
||||
}
|
||||
|
||||
static void hello() {
|
||||
pthread_mutex_lock(&g_print_mutex);
|
||||
printf("hello, world\n");
|
||||
pthread_mutex_unlock(&g_print_mutex);
|
||||
}
|
||||
|
||||
static void *thread_func(void *arg) {
|
||||
static pthread_mutex_t s_thread_index_mutex = PTHREAD_MUTEX_INITIALIZER;
|
||||
static int s_thread_index = 1;
|
||||
|
||||
pthread_mutex_lock(&s_thread_index_mutex);
|
||||
const int this_thread_index = s_thread_index++;
|
||||
pthread_mutex_unlock(&s_thread_index_mutex);
|
||||
|
||||
if (g_print_thread_ids) {
|
||||
pthread_mutex_lock(&g_print_mutex);
|
||||
printf("thread %d id: ", this_thread_index);
|
||||
print_thread_id();
|
||||
printf("\n");
|
||||
pthread_mutex_unlock(&g_print_mutex);
|
||||
}
|
||||
|
||||
if (g_threads_do_segfault) {
|
||||
// Sleep for a number of seconds based on the thread index.
|
||||
// TODO add ability to send commands to test exe so we can
|
||||
// handle timing more precisely. This is clunky. All we're
|
||||
// trying to do is add predictability as to the timing of
|
||||
// signal generation by created threads.
|
||||
int sleep_seconds = 2 * (this_thread_index - 1);
|
||||
while (sleep_seconds > 0)
|
||||
sleep_seconds = sleep(sleep_seconds);
|
||||
|
||||
// Test creating a SEGV.
|
||||
pthread_mutex_lock(&g_jump_buffer_mutex);
|
||||
g_is_segfaulting = true;
|
||||
int *bad_p = nullptr;
|
||||
if (setjmp(g_jump_buffer) == 0) {
|
||||
// Force a seg fault signal on this thread.
|
||||
*bad_p = 0;
|
||||
} else {
|
||||
// Tell the system we're no longer seg faulting.
|
||||
// Used by the SIGUSR1 signal handler that we inject
|
||||
// in place of the SIGSEGV so it only tries to
|
||||
// recover from the SIGSEGV if this seg fault code
|
||||
// was in play.
|
||||
g_is_segfaulting = false;
|
||||
}
|
||||
pthread_mutex_unlock(&g_jump_buffer_mutex);
|
||||
|
||||
pthread_mutex_lock(&g_print_mutex);
|
||||
printf("thread ");
|
||||
print_thread_id();
|
||||
printf(": past SIGSEGV\n");
|
||||
pthread_mutex_unlock(&g_print_mutex);
|
||||
}
|
||||
|
||||
int sleep_seconds_remaining = 60;
|
||||
while (sleep_seconds_remaining > 0) {
|
||||
sleep_seconds_remaining = sleep(sleep_seconds_remaining);
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
lldb_enable_attach();
|
||||
|
||||
std::vector<pthread_t> threads;
|
||||
std::unique_ptr<uint8_t[]> heap_array_up;
|
||||
int return_value = 0;
|
||||
|
||||
// Set the signal handler.
|
||||
sig_t sig_result = signal(SIGALRM, signal_handler);
|
||||
if (sig_result == SIG_ERR) {
|
||||
fprintf(stderr, "failed to set SIGALRM signal handler: errno=%d\n", errno);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
sig_result = signal(SIGUSR1, signal_handler);
|
||||
if (sig_result == SIG_ERR) {
|
||||
fprintf(stderr, "failed to set SIGUSR1 handler: errno=%d\n", errno);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
sig_result = signal(SIGSEGV, signal_handler);
|
||||
if (sig_result == SIG_ERR) {
|
||||
fprintf(stderr, "failed to set SIGUSR1 handler: errno=%d\n", errno);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
// Process command line args.
|
||||
for (int i = 1; i < argc; ++i) {
|
||||
if (std::strstr(argv[i], STDERR_PREFIX)) {
|
||||
// Treat remainder as text to go to stderr.
|
||||
fprintf(stderr, "%s\n", (argv[i] + strlen(STDERR_PREFIX)));
|
||||
} else if (std::strstr(argv[i], RETVAL_PREFIX)) {
|
||||
// Treat as the return value for the program.
|
||||
return_value = std::atoi(argv[i] + strlen(RETVAL_PREFIX));
|
||||
} else if (std::strstr(argv[i], SLEEP_PREFIX)) {
|
||||
// Treat as the amount of time to have this process sleep (in seconds).
|
||||
int sleep_seconds_remaining = std::atoi(argv[i] + strlen(SLEEP_PREFIX));
|
||||
|
||||
// Loop around, sleeping until all sleep time is used up. Note that
|
||||
// signals will cause sleep to end early with the number of seconds
|
||||
// remaining.
|
||||
for (int i = 0; sleep_seconds_remaining > 0; ++i) {
|
||||
sleep_seconds_remaining = sleep(sleep_seconds_remaining);
|
||||
// std::cout << "sleep result (call " << i << "): " <<
|
||||
// sleep_seconds_remaining << std::endl;
|
||||
}
|
||||
} else if (std::strstr(argv[i], SET_MESSAGE_PREFIX)) {
|
||||
// Copy the contents after "set-message:" to the g_message buffer.
|
||||
// Used for reading inferior memory and verifying contents match
|
||||
// expectations.
|
||||
strncpy(g_message, argv[i] + strlen(SET_MESSAGE_PREFIX),
|
||||
sizeof(g_message));
|
||||
|
||||
// Ensure we're null terminated.
|
||||
g_message[sizeof(g_message) - 1] = '\0';
|
||||
|
||||
} else if (std::strstr(argv[i], PRINT_MESSAGE_COMMAND)) {
|
||||
pthread_mutex_lock(&g_print_mutex);
|
||||
printf("message: %s\n", g_message);
|
||||
pthread_mutex_unlock(&g_print_mutex);
|
||||
} else if (std::strstr(argv[i], GET_DATA_ADDRESS_PREFIX)) {
|
||||
volatile void *data_p = nullptr;
|
||||
|
||||
if (std::strstr(argv[i] + strlen(GET_DATA_ADDRESS_PREFIX), "g_message"))
|
||||
data_p = &g_message[0];
|
||||
else if (std::strstr(argv[i] + strlen(GET_DATA_ADDRESS_PREFIX), "g_c1"))
|
||||
data_p = &g_c1;
|
||||
else if (std::strstr(argv[i] + strlen(GET_DATA_ADDRESS_PREFIX), "g_c2"))
|
||||
data_p = &g_c2;
|
||||
|
||||
pthread_mutex_lock(&g_print_mutex);
|
||||
printf("data address: %p\n", data_p);
|
||||
pthread_mutex_unlock(&g_print_mutex);
|
||||
} else if (std::strstr(argv[i], GET_HEAP_ADDRESS_COMMAND)) {
|
||||
// Create a byte array if not already present.
|
||||
if (!heap_array_up)
|
||||
heap_array_up.reset(new uint8_t[32]);
|
||||
|
||||
pthread_mutex_lock(&g_print_mutex);
|
||||
printf("heap address: %p\n", heap_array_up.get());
|
||||
pthread_mutex_unlock(&g_print_mutex);
|
||||
} else if (std::strstr(argv[i], GET_STACK_ADDRESS_COMMAND)) {
|
||||
pthread_mutex_lock(&g_print_mutex);
|
||||
printf("stack address: %p\n", &return_value);
|
||||
pthread_mutex_unlock(&g_print_mutex);
|
||||
} else if (std::strstr(argv[i], GET_CODE_ADDRESS_PREFIX)) {
|
||||
void (*func_p)() = nullptr;
|
||||
|
||||
if (std::strstr(argv[i] + strlen(GET_CODE_ADDRESS_PREFIX), "hello"))
|
||||
func_p = hello;
|
||||
else if (std::strstr(argv[i] + strlen(GET_CODE_ADDRESS_PREFIX),
|
||||
"swap_chars"))
|
||||
func_p = swap_chars;
|
||||
|
||||
pthread_mutex_lock(&g_print_mutex);
|
||||
printf("code address: %p\n", func_p);
|
||||
pthread_mutex_unlock(&g_print_mutex);
|
||||
} else if (std::strstr(argv[i], CALL_FUNCTION_PREFIX)) {
|
||||
// Defaut to providing the address of main.
|
||||
if (std::strcmp(argv[i] + strlen(CALL_FUNCTION_PREFIX), "hello") == 0)
|
||||
hello();
|
||||
else if (std::strcmp(argv[i] + strlen(CALL_FUNCTION_PREFIX),
|
||||
"swap_chars") == 0)
|
||||
swap_chars();
|
||||
else {
|
||||
pthread_mutex_lock(&g_print_mutex);
|
||||
printf("unknown function: %s\n",
|
||||
argv[i] + strlen(CALL_FUNCTION_PREFIX));
|
||||
pthread_mutex_unlock(&g_print_mutex);
|
||||
}
|
||||
} else if (std::strstr(argv[i], THREAD_PREFIX)) {
|
||||
// Check if we're creating a new thread.
|
||||
if (std::strstr(argv[i] + strlen(THREAD_PREFIX), THREAD_COMMAND_NEW)) {
|
||||
// Create a new thread.
|
||||
pthread_t new_thread;
|
||||
const int err =
|
||||
::pthread_create(&new_thread, nullptr, thread_func, nullptr);
|
||||
if (err) {
|
||||
fprintf(stderr, "pthread_create() failed with error code %d\n", err);
|
||||
exit(err);
|
||||
}
|
||||
threads.push_back(new_thread);
|
||||
} else if (std::strstr(argv[i] + strlen(THREAD_PREFIX),
|
||||
THREAD_COMMAND_PRINT_IDS)) {
|
||||
// Turn on thread id announcing.
|
||||
g_print_thread_ids = true;
|
||||
|
||||
// And announce us.
|
||||
pthread_mutex_lock(&g_print_mutex);
|
||||
printf("thread 0 id: ");
|
||||
print_thread_id();
|
||||
printf("\n");
|
||||
pthread_mutex_unlock(&g_print_mutex);
|
||||
} else if (std::strstr(argv[i] + strlen(THREAD_PREFIX),
|
||||
THREAD_COMMAND_SEGFAULT)) {
|
||||
g_threads_do_segfault = true;
|
||||
} else {
|
||||
// At this point we don't do anything else with threads.
|
||||
// Later use thread index and send command to thread.
|
||||
}
|
||||
} else {
|
||||
// Treat the argument as text for stdout.
|
||||
printf("%s\n", argv[i]);
|
||||
}
|
||||
}
|
||||
|
||||
// If we launched any threads, join them
|
||||
for (std::vector<pthread_t>::iterator it = threads.begin();
|
||||
it != threads.end(); ++it) {
|
||||
void *thread_retval = nullptr;
|
||||
const int err = ::pthread_join(*it, &thread_retval);
|
||||
if (err != 0)
|
||||
fprintf(stderr, "pthread_join() failed with error code %d\n", err);
|
||||
}
|
||||
|
||||
return return_value;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2,38 +2,30 @@
|
|||
#include <cstring>
|
||||
#include <iostream>
|
||||
|
||||
namespace
|
||||
{
|
||||
const char *const SEGFAULT_COMMAND = "segfault";
|
||||
const char *const ABORT_COMMAND = "abort";
|
||||
namespace {
|
||||
const char *const SEGFAULT_COMMAND = "segfault";
|
||||
const char *const ABORT_COMMAND = "abort";
|
||||
}
|
||||
|
||||
int main (int argc, char **argv)
|
||||
{
|
||||
if (argc < 2)
|
||||
{
|
||||
std::cout << "expected at least one command provided on the command line" << std::endl;
|
||||
}
|
||||
int main(int argc, char **argv) {
|
||||
if (argc < 2) {
|
||||
std::cout << "expected at least one command provided on the command line"
|
||||
<< std::endl;
|
||||
}
|
||||
|
||||
// Process command line args.
|
||||
for (int i = 1; i < argc; ++i)
|
||||
{
|
||||
const char *const command = argv[i];
|
||||
if (std::strstr (command, SEGFAULT_COMMAND))
|
||||
{
|
||||
// Perform a null pointer access.
|
||||
int *const null_int_ptr = nullptr;
|
||||
*null_int_ptr = 0xDEAD;
|
||||
}
|
||||
else if (std::strstr (command, ABORT_COMMAND))
|
||||
{
|
||||
std::abort();
|
||||
}
|
||||
else
|
||||
{
|
||||
std::cout << "Unsupported command: " << command << std::endl;
|
||||
}
|
||||
// Process command line args.
|
||||
for (int i = 1; i < argc; ++i) {
|
||||
const char *const command = argv[i];
|
||||
if (std::strstr(command, SEGFAULT_COMMAND)) {
|
||||
// Perform a null pointer access.
|
||||
int *const null_int_ptr = nullptr;
|
||||
*null_int_ptr = 0xDEAD;
|
||||
} else if (std::strstr(command, ABORT_COMMAND)) {
|
||||
std::abort();
|
||||
} else {
|
||||
std::cout << "Unsupported command: " << command << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,7 +1,6 @@
|
|||
#include <cstdio>
|
||||
|
||||
int main (int argc, char **argv)
|
||||
{
|
||||
printf("argc: %d\n", argc);
|
||||
return argv[0][0];
|
||||
int main(int argc, char **argv) {
|
||||
printf("argc: %d\n", argc);
|
||||
return argv[0][0];
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue