Diff 89480

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/.clang-format

BasedOnStyle: LLVM

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/main.cpp

				//===-- main.cpp ------------------------------------------------- C++ --===//
				//
				// The LLVM Compiler Infrastructure
				//
				// This file is distributed under the University of Illinois Open Source
				// License. See LICENSE.TXT for details.
				//
				//===----------------------------------------------------------------------===//

	#include <cstdlib>			#include <cstdlib>
	#include <cstring>			#include <cstring>
	#include <errno.h>			#include <errno.h>
	#include <inttypes.h>			#include <inttypes.h>
	#include <memory>			#include <memory>
	#include <pthread.h>			#include <pthread.h>
	#include <setjmp.h>			#include <setjmp.h>
	#include <signal.h>			#include <signal.h>
	#include <stdint.h>			#include <stdint.h>
	#include <stdio.h>			#include <stdio.h>
	#include <string.h>			#include <string.h>
	#include <time.h>			#include <time.h>
	#include <unistd.h>			#include <unistd.h>
	#include <vector>			#include <vector>

	#if defined(__APPLE__)			#if defined(__APPLE__)
	__OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2)			__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__)			#elif defined(__linux__)
	#include <sys/syscall.h>			#include <sys/syscall.h>
	#endif			#endif

	static const char *const RETVAL_PREFIX = "retval:";			static const char *const RETVAL_PREFIX = "retval:";
	static const char *const SLEEP_PREFIX = "sleep:";			static const char *const SLEEP_PREFIX = "sleep:";
	static const char *const STDERR_PREFIX = "stderr:";			static const char *const STDERR_PREFIX = "stderr:";
	static const char *const SET_MESSAGE_PREFIX = "set-message:";			static const char *const SET_MESSAGE_PREFIX = "set-message:";
	static const char *const PRINT_MESSAGE_COMMAND = "print-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_DATA_ADDRESS_PREFIX = "get-data-address-hex:";
	static const char *const GET_STACK_ADDRESS_COMMAND = "get-stack-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_HEAP_ADDRESS_COMMAND = "get-heap-address-hex:";

	static const char *const GET_CODE_ADDRESS_PREFIX = "get-code-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 CALL_FUNCTION_PREFIX = "call-function:";

	static const char *const THREAD_PREFIX = "thread:";			static const char *const THREAD_PREFIX = "thread:";
	static const char *const THREAD_COMMAND_NEW = "new";			static const char *const THREAD_COMMAND_NEW = "new";
	static const char *const THREAD_COMMAND_PRINT_IDS = "print-ids";			static const char *const THREAD_COMMAND_PRINT_IDS = "print-ids";
	static const char *const THREAD_COMMAND_SEGFAULT = "segfault";			static const char *const THREAD_COMMAND_SEGFAULT = "segfault";

	static bool g_print_thread_ids = false;			static bool g_print_thread_ids = false;
	static pthread_mutex_t g_print_mutex = PTHREAD_MUTEX_INITIALIZER;			static pthread_mutex_t g_print_mutex = PTHREAD_MUTEX_INITIALIZER;
	static bool g_threads_do_segfault = false;			static bool g_threads_do_segfault = false;

	static pthread_mutex_t g_jump_buffer_mutex = PTHREAD_MUTEX_INITIALIZER;			static pthread_mutex_t g_jump_buffer_mutex = PTHREAD_MUTEX_INITIALIZER;
	static jmp_buf g_jump_buffer;			static jmp_buf g_jump_buffer;
	static bool g_is_segfaulting = false;			static bool g_is_segfaulting = false;

	static char g_message[256];			static char g_message[256];

	static volatile char g_c1 = '0';			static volatile char g_c1 = '0';
	static volatile char g_c2 = '1';			static volatile char g_c2 = '1';

	static void			static void print_thread_id() {
	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
	// 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.			// clause print out the unsupported text so that the unit test knows to skip
	// Otherwise, let the else clause print out the unsupported text so that the unit test knows to skip verifying thread ids.			// verifying thread ids.
	#if defined(__APPLE__)			#if defined(__APPLE__)
	__uint64_t tid = 0;			__uint64_t tid = 0;
	pthread_threadid_np(pthread_self(), &tid);			pthread_threadid_np(pthread_self(), &tid);
	printf ("%" PRIx64, tid);			printf("%" PRIx64, tid);
	#elif defined (__linux__)			#elif defined(__linux__)
	// This is a call to gettid() via syscall.			// This is a call to gettid() via syscall.
	printf ("%" PRIx64, static_cast<uint64_t> (syscall (__NR_gettid)));			printf("%" PRIx64, static_cast<uint64_t>(syscall(__NR_gettid)));
	#else			#else
	printf("{no-tid-support}");			printf("{no-tid-support}");
	#endif			#endif
	}			}

	static void			static void signal_handler(int signo) {
	signal_handler (int signo)
	{
	const char *signal_name = nullptr;			const char *signal_name = nullptr;
	switch (signo)			switch (signo) {
	{			case SIGUSR1:
	case SIGUSR1: signal_name = "SIGUSR1"; break;			signal_name = "SIGUSR1";
	case SIGSEGV: signal_name = "SIGSEGV"; break;			break;
	default: signal_name = nullptr;			case SIGSEGV:
				signal_name = "SIGSEGV";
				break;
				default:
				signal_name = nullptr;
	}			}

	// Print notice that we received the signal on a given thread.			// Print notice that we received the signal on a given thread.
	pthread_mutex_lock (&g_print_mutex);			pthread_mutex_lock(&g_print_mutex);
	if (signal_name)			if (signal_name)
	printf ("received %s on thread id: ", signal_name);			printf("received %s on thread id: ", signal_name);
	else			else
	printf ("received signo %d (%s) on thread id: ", signo, strsignal (signo));			printf("received signo %d (%s) on thread id: ", signo, strsignal(signo));
	print_thread_id ();			print_thread_id();
	printf ("\n");			printf("\n");
	pthread_mutex_unlock (&g_print_mutex);			pthread_mutex_unlock(&g_print_mutex);

	// Reset the signal handler if we're one of the expected signal handlers.			// Reset the signal handler if we're one of the expected signal handlers.
	switch (signo)			switch (signo) {
	{
	case SIGSEGV:			case SIGSEGV:
	if (g_is_segfaulting)			if (g_is_segfaulting) {
	{			// Fix up the pointer we're writing to. This needs to happen if nothing
	// Fix up the pointer we're writing to. This needs to happen if nothing intercepts the SIGSEGV			// intercepts the SIGSEGV (i.e. if somebody runs this from the command
	// (i.e. if somebody runs this from the command line).			// line).
	longjmp(g_jump_buffer, 1);			longjmp(g_jump_buffer, 1);
	}			}
	break;			break;
	case SIGUSR1:			case SIGUSR1:
	if (g_is_segfaulting)			if (g_is_segfaulting) {
	{			// Fix up the pointer we're writing to. This is used to test gdb remote
	// Fix up the pointer we're writing to. This is used to test gdb remote signal delivery.			// signal delivery. A SIGSEGV will be raised when the thread is created,
	// A SIGSEGV will be raised when the thread is created, switched out for a SIGUSR1, and			// switched out for a SIGUSR1, and then this code still needs to fix the
	// then this code still needs to fix the seg fault.			// seg fault. (i.e. if somebody runs this from the command line).
	// (i.e. if somebody runs this from the command line).
	longjmp(g_jump_buffer, 1);			longjmp(g_jump_buffer, 1);
	}			}
	break;			break;
	}			}

	// Reset the signal handler.			// Reset the signal handler.
	sig_t sig_result = signal (signo, signal_handler);			sig_t sig_result = signal(signo, signal_handler);
	if (sig_result == SIG_ERR)			if (sig_result == SIG_ERR) {
	{
	fprintf(stderr, "failed to set signal handler: errno=%d\n", errno);			fprintf(stderr, "failed to set signal handler: errno=%d\n", errno);
	exit (1);			exit(1);
	}			}
	}			}

	static void			static void swap_chars() {
	swap_chars ()
	{
	g_c1 = '1';			g_c1 = '1';
	g_c2 = '0';			g_c2 = '0';

	g_c1 = '0';			g_c1 = '0';
	g_c2 = '1';			g_c2 = '1';
	}			}

	static void			static void hello() {
	hello ()
	{
	pthread_mutex_lock (&g_print_mutex);			pthread_mutex_lock(&g_print_mutex);
	printf ("hello, world\n");			printf("hello, world\n");
	pthread_mutex_unlock (&g_print_mutex);			pthread_mutex_unlock(&g_print_mutex);
	}			}

	static void*			static void thread_func(void arg) {
	thread_func (void *arg)
	{
	static pthread_mutex_t s_thread_index_mutex = PTHREAD_MUTEX_INITIALIZER;			static pthread_mutex_t s_thread_index_mutex = PTHREAD_MUTEX_INITIALIZER;
	static int s_thread_index = 1;			static int s_thread_index = 1;

	pthread_mutex_lock (&s_thread_index_mutex);			pthread_mutex_lock(&s_thread_index_mutex);
	const int this_thread_index = s_thread_index++;			const int this_thread_index = s_thread_index++;
	pthread_mutex_unlock (&s_thread_index_mutex);			pthread_mutex_unlock(&s_thread_index_mutex);

	if (g_print_thread_ids)			if (g_print_thread_ids) {
	{
	pthread_mutex_lock (&g_print_mutex);			pthread_mutex_lock(&g_print_mutex);
	printf ("thread %d id: ", this_thread_index);			printf("thread %d id: ", this_thread_index);
	print_thread_id ();			print_thread_id();
	printf ("\n");			printf("\n");
	pthread_mutex_unlock (&g_print_mutex);			pthread_mutex_unlock(&g_print_mutex);
	}			}

	if (g_threads_do_segfault)			if (g_threads_do_segfault) {
	{
	// Sleep for a number of seconds based on the thread index.			// Sleep for a number of seconds based on the thread index.
	// TODO add ability to send commands to test exe so we can			// TODO add ability to send commands to test exe so we can
	// handle timing more precisely. This is clunky. All we're			// handle timing more precisely. This is clunky. All we're
	// trying to do is add predictability as to the timing of			// trying to do is add predictability as to the timing of
	// signal generation by created threads.			// signal generation by created threads.
	int sleep_seconds = 2 * (this_thread_index - 1);			int sleep_seconds = 2 * (this_thread_index - 1);
	while (sleep_seconds > 0)			while (sleep_seconds > 0)
	sleep_seconds = sleep(sleep_seconds);			sleep_seconds = sleep(sleep_seconds);

	// Test creating a SEGV.			// Test creating a SEGV.
	pthread_mutex_lock (&g_jump_buffer_mutex);			pthread_mutex_lock(&g_jump_buffer_mutex);
	g_is_segfaulting = true;			g_is_segfaulting = true;
	int *bad_p = nullptr;			int *bad_p = nullptr;
	if (setjmp(g_jump_buffer) == 0)			if (setjmp(g_jump_buffer) == 0) {
	{
	// Force a seg fault signal on this thread.			// Force a seg fault signal on this thread.
	*bad_p = 0;			*bad_p = 0;
	}			} else {
	else
	{
	// Tell the system we're no longer seg faulting.			// Tell the system we're no longer seg faulting.
	// Used by the SIGUSR1 signal handler that we inject			// Used by the SIGUSR1 signal handler that we inject
	// in place of the SIGSEGV so it only tries to			// in place of the SIGSEGV so it only tries to
	// recover from the SIGSEGV if this seg fault code			// recover from the SIGSEGV if this seg fault code
	// was in play.			// was in play.
	g_is_segfaulting = false;			g_is_segfaulting = false;
	}			}
	pthread_mutex_unlock (&g_jump_buffer_mutex);			pthread_mutex_unlock(&g_jump_buffer_mutex);

	pthread_mutex_lock (&g_print_mutex);			pthread_mutex_lock(&g_print_mutex);
	printf ("thread ");			printf("thread ");
	print_thread_id ();			print_thread_id();
	printf (": past SIGSEGV\n");			printf(": past SIGSEGV\n");
	pthread_mutex_unlock (&g_print_mutex);			pthread_mutex_unlock(&g_print_mutex);
	}			}

	int sleep_seconds_remaining = 60;			int sleep_seconds_remaining = 60;
	while (sleep_seconds_remaining > 0)			while (sleep_seconds_remaining > 0) {
	{
	sleep_seconds_remaining = sleep (sleep_seconds_remaining);			sleep_seconds_remaining = sleep(sleep_seconds_remaining);
	}			}

	return nullptr;			return nullptr;
	}			}

	int main (int argc, char **argv)			int main(int argc, char **argv) {
	{
	lldb_enable_attach();			lldb_enable_attach();

	std::vector<pthread_t> threads;			std::vector<pthread_t> threads;
	std::unique_ptr<uint8_t[]> heap_array_up;			std::unique_ptr<uint8_t[]> heap_array_up;
	int return_value = 0;			int return_value = 0;

	// Set the signal handler.			// Set the signal handler.
	sig_t sig_result = signal (SIGALRM, signal_handler);			sig_t sig_result = signal(SIGALRM, signal_handler);
	if (sig_result == SIG_ERR)			if (sig_result == SIG_ERR) {
	{
	fprintf(stderr, "failed to set SIGALRM signal handler: errno=%d\n", errno);			fprintf(stderr, "failed to set SIGALRM signal handler: errno=%d\n", errno);
	exit (1);			exit(1);
	}			}

	sig_result = signal (SIGUSR1, signal_handler);			sig_result = signal(SIGUSR1, signal_handler);
	if (sig_result == SIG_ERR)			if (sig_result == SIG_ERR) {
	{
	fprintf(stderr, "failed to set SIGUSR1 handler: errno=%d\n", errno);			fprintf(stderr, "failed to set SIGUSR1 handler: errno=%d\n", errno);
	exit (1);			exit(1);
	}			}

	sig_result = signal (SIGSEGV, signal_handler);			sig_result = signal(SIGSEGV, signal_handler);
	if (sig_result == SIG_ERR)			if (sig_result == SIG_ERR) {
	{
	fprintf(stderr, "failed to set SIGUSR1 handler: errno=%d\n", errno);			fprintf(stderr, "failed to set SIGUSR1 handler: errno=%d\n", errno);
	exit (1);			exit(1);
	}			}

	// Process command line args.			// Process command line args.
	for (int i = 1; i < argc; ++i)			for (int i = 1; i < argc; ++i) {
	{			if (std::strstr(argv[i], STDERR_PREFIX)) {
	if (std::strstr (argv[i], STDERR_PREFIX))
	{
	// Treat remainder as text to go to stderr.			// Treat remainder as text to go to stderr.
	fprintf (stderr, "%s\n", (argv[i] + strlen (STDERR_PREFIX)));			fprintf(stderr, "%s\n", (argv[i] + strlen(STDERR_PREFIX)));
	}			} else if (std::strstr(argv[i], RETVAL_PREFIX)) {
	else if (std::strstr (argv[i], RETVAL_PREFIX))
	{
	// Treat as the return value for the program.			// Treat as the return value for the program.
	return_value = std::atoi (argv[i] + strlen (RETVAL_PREFIX));			return_value = std::atoi(argv[i] + strlen(RETVAL_PREFIX));
	}			} else if (std::strstr(argv[i], SLEEP_PREFIX)) {
	else if (std::strstr (argv[i], SLEEP_PREFIX))
	{
	// Treat as the amount of time to have this process sleep (in seconds).			// Treat as the amount of time to have this process sleep (in seconds).
	int sleep_seconds_remaining = std::atoi (argv[i] + strlen (SLEEP_PREFIX));			int sleep_seconds_remaining = std::atoi(argv[i] + strlen(SLEEP_PREFIX));

	// Loop around, sleeping until all sleep time is used up. Note that			// 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.			// signals will cause sleep to end early with the number of seconds
	for (int i = 0; sleep_seconds_remaining > 0; ++i)			// remaining.
	{			for (int i = 0; sleep_seconds_remaining > 0; ++i) {
	sleep_seconds_remaining = sleep (sleep_seconds_remaining);			sleep_seconds_remaining = sleep(sleep_seconds_remaining);
	// std::cout << "sleep result (call " << i << "): " << sleep_seconds_remaining << std::endl;			// std::cout << "sleep result (call " << i << "): " <<
				// sleep_seconds_remaining << std::endl;
	}			}
	}			} else if (std::strstr(argv[i], SET_MESSAGE_PREFIX)) {
	else if (std::strstr (argv[i], SET_MESSAGE_PREFIX))
	{
	// Copy the contents after "set-message:" to the g_message buffer.			// Copy the contents after "set-message:" to the g_message buffer.
	// Used for reading inferior memory and verifying contents match expectations.			// Used for reading inferior memory and verifying contents match
	strncpy (g_message, argv[i] + strlen (SET_MESSAGE_PREFIX), sizeof (g_message));			// expectations.
				strncpy(g_message, argv[i] + strlen(SET_MESSAGE_PREFIX),
				sizeof(g_message));

	// Ensure we're null terminated.			// Ensure we're null terminated.
	g_message[sizeof (g_message) - 1] = '\0';			g_message[sizeof(g_message) - 1] = '\0';

	}			} else if (std::strstr(argv[i], PRINT_MESSAGE_COMMAND)) {
	else if (std::strstr (argv[i], PRINT_MESSAGE_COMMAND))
	{
	pthread_mutex_lock (&g_print_mutex);			pthread_mutex_lock(&g_print_mutex);
	printf ("message: %s\n", g_message);			printf("message: %s\n", g_message);
	pthread_mutex_unlock (&g_print_mutex);			pthread_mutex_unlock(&g_print_mutex);
	}			} else if (std::strstr(argv[i], GET_DATA_ADDRESS_PREFIX)) {
	else if (std::strstr (argv[i], GET_DATA_ADDRESS_PREFIX))
	{
	volatile void *data_p = nullptr;			volatile void *data_p = nullptr;

	if (std::strstr (argv[i] + strlen (GET_DATA_ADDRESS_PREFIX), "g_message"))			if (std::strstr(argv[i] + strlen(GET_DATA_ADDRESS_PREFIX), "g_message"))
	data_p = &g_message[0];			data_p = &g_message[0];
	else if (std::strstr (argv[i] + strlen (GET_DATA_ADDRESS_PREFIX), "g_c1"))			else if (std::strstr(argv[i] + strlen(GET_DATA_ADDRESS_PREFIX), "g_c1"))
	data_p = &g_c1;			data_p = &g_c1;
	else if (std::strstr (argv[i] + strlen (GET_DATA_ADDRESS_PREFIX), "g_c2"))			else if (std::strstr(argv[i] + strlen(GET_DATA_ADDRESS_PREFIX), "g_c2"))
	data_p = &g_c2;			data_p = &g_c2;

	pthread_mutex_lock (&g_print_mutex);			pthread_mutex_lock(&g_print_mutex);
	printf ("data address: %p\n", data_p);			printf("data address: %p\n", data_p);
	pthread_mutex_unlock (&g_print_mutex);			pthread_mutex_unlock(&g_print_mutex);
	}			} else if (std::strstr(argv[i], GET_HEAP_ADDRESS_COMMAND)) {
	else if (std::strstr (argv[i], GET_HEAP_ADDRESS_COMMAND))
	{
	// Create a byte array if not already present.			// Create a byte array if not already present.
	if (!heap_array_up)			if (!heap_array_up)
	heap_array_up.reset (new uint8_t[32]);			heap_array_up.reset(new uint8_t[32]);

	pthread_mutex_lock (&g_print_mutex);			pthread_mutex_lock(&g_print_mutex);
	printf ("heap address: %p\n", heap_array_up.get ());			printf("heap address: %p\n", heap_array_up.get());
	pthread_mutex_unlock (&g_print_mutex);			pthread_mutex_unlock(&g_print_mutex);
	}			} else if (std::strstr(argv[i], GET_STACK_ADDRESS_COMMAND)) {
	else if (std::strstr (argv[i], GET_STACK_ADDRESS_COMMAND))
	{
	pthread_mutex_lock (&g_print_mutex);			pthread_mutex_lock(&g_print_mutex);
	printf ("stack address: %p\n", &return_value);			printf("stack address: %p\n", &return_value);
	pthread_mutex_unlock (&g_print_mutex);			pthread_mutex_unlock(&g_print_mutex);
	}			} else if (std::strstr(argv[i], GET_CODE_ADDRESS_PREFIX)) {
	else if (std::strstr (argv[i], GET_CODE_ADDRESS_PREFIX))
	{
	void (*func_p)() = nullptr;			void (*func_p)() = nullptr;

	if (std::strstr (argv[i] + strlen (GET_CODE_ADDRESS_PREFIX), "hello"))			if (std::strstr(argv[i] + strlen(GET_CODE_ADDRESS_PREFIX), "hello"))
	func_p = hello;			func_p = hello;
	else if (std::strstr (argv[i] + strlen (GET_CODE_ADDRESS_PREFIX), "swap_chars"))			else if (std::strstr(argv[i] + strlen(GET_CODE_ADDRESS_PREFIX),
				"swap_chars"))
	func_p = swap_chars;			func_p = swap_chars;

	pthread_mutex_lock (&g_print_mutex);			pthread_mutex_lock(&g_print_mutex);
	printf ("code address: %p\n", func_p);			printf("code address: %p\n", func_p);
	pthread_mutex_unlock (&g_print_mutex);			pthread_mutex_unlock(&g_print_mutex);
	}			} else if (std::strstr(argv[i], CALL_FUNCTION_PREFIX)) {
	else if (std::strstr (argv[i], CALL_FUNCTION_PREFIX))
	{
	// Defaut to providing the address of main.			// Defaut to providing the address of main.
	if (std::strcmp (argv[i] + strlen (CALL_FUNCTION_PREFIX), "hello") == 0)			if (std::strcmp(argv[i] + strlen(CALL_FUNCTION_PREFIX), "hello") == 0)
	hello();			hello();
	else if (std::strcmp (argv[i] + strlen (CALL_FUNCTION_PREFIX), "swap_chars") == 0)			else if (std::strcmp(argv[i] + strlen(CALL_FUNCTION_PREFIX),
				"swap_chars") == 0)
	swap_chars();			swap_chars();
	else			else {
	{
	pthread_mutex_lock (&g_print_mutex);			pthread_mutex_lock(&g_print_mutex);
	printf ("unknown function: %s\n", argv[i] + strlen (CALL_FUNCTION_PREFIX));			printf("unknown function: %s\n",
				argv[i] + strlen(CALL_FUNCTION_PREFIX));
	pthread_mutex_unlock (&g_print_mutex);			pthread_mutex_unlock(&g_print_mutex);
	}			}
	}			} else if (std::strstr(argv[i], THREAD_PREFIX)) {
	else if (std::strstr (argv[i], THREAD_PREFIX))
	{
	// Check if we're creating a new thread.			// Check if we're creating a new thread.
	if (std::strstr (argv[i] + strlen(THREAD_PREFIX), THREAD_COMMAND_NEW))			if (std::strstr(argv[i] + strlen(THREAD_PREFIX), THREAD_COMMAND_NEW)) {
	{
	// Create a new thread.			// Create a new thread.
	pthread_t new_thread;			pthread_t new_thread;
	const int err = ::pthread_create (&new_thread, nullptr, thread_func, nullptr);			const int err =
	if (err)			::pthread_create(&new_thread, nullptr, thread_func, nullptr);
	{			if (err) {
	fprintf (stderr, "pthread_create() failed with error code %d\n", err);			fprintf(stderr, "pthread_create() failed with error code %d\n", err);
	exit (err);			exit(err);
	}			}
	threads.push_back (new_thread);			threads.push_back(new_thread);
	}			} else if (std::strstr(argv[i] + strlen(THREAD_PREFIX),
	else if (std::strstr (argv[i] + strlen(THREAD_PREFIX), THREAD_COMMAND_PRINT_IDS))			THREAD_COMMAND_PRINT_IDS)) {
	{
	// Turn on thread id announcing.			// Turn on thread id announcing.
	g_print_thread_ids = true;			g_print_thread_ids = true;

	// And announce us.			// And announce us.
	pthread_mutex_lock (&g_print_mutex);			pthread_mutex_lock(&g_print_mutex);
	printf ("thread 0 id: ");			printf("thread 0 id: ");
	print_thread_id ();			print_thread_id();
	printf ("\n");			printf("\n");
	pthread_mutex_unlock (&g_print_mutex);			pthread_mutex_unlock(&g_print_mutex);
	}			} else if (std::strstr(argv[i] + strlen(THREAD_PREFIX),
	else if (std::strstr (argv[i] + strlen(THREAD_PREFIX), THREAD_COMMAND_SEGFAULT))			THREAD_COMMAND_SEGFAULT)) {
	{
	g_threads_do_segfault = true;			g_threads_do_segfault = true;
	}			} else {
	else
	{
	// At this point we don't do anything else with threads.			// At this point we don't do anything else with threads.
	// Later use thread index and send command to thread.			// Later use thread index and send command to thread.
	}			}
	}			} else {
	else
	{
	// Treat the argument as text for stdout.			// Treat the argument as text for stdout.
	printf("%s\n", argv[i]);			printf("%s\n", argv[i]);
	}			}
	}			}

	// If we launched any threads, join them			// If we launched any threads, join them
	for (std::vector<pthread_t>::iterator it = threads.begin (); it != threads.end (); ++it)			for (std::vector<pthread_t>::iterator it = threads.begin();
	{			it != threads.end(); ++it) {
	void *thread_retval = nullptr;			void *thread_retval = nullptr;
	const int err = ::pthread_join (*it, &thread_retval);			const int err = ::pthread_join(*it, &thread_retval);
	if (err != 0)			if (err != 0)
	fprintf (stderr, "pthread_join() failed with error code %d\n", err);			fprintf(stderr, "pthread_join() failed with error code %d\n", err);
	}			}

	return return_value;			return return_value;
	}			}

This is an archive of the discontinued LLVM Phabricator instance.

Reformat inferior's main.cpp in lldb-server test
ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 89480

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/.clang-format

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/main.cpp

This is an archive of the discontinued LLVM Phabricator instance.

Reformat inferior's main.cpp in lldb-server testClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 89480

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/.clang-format

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/main.cpp

Reformat inferior's main.cpp in lldb-server test
ClosedPublic