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

[eugene]

Summary

main.cpp is complete mess of tabs and spaces. This change brings it to compliance with LLVM coding style.

[jmajors]

Do we have any plans to put something like cpplint into effect?

[eugene]

In D30234#682990, @jmajors wrote:

Do we have any plans to put something like cpplint into effect?

First step would be to have warning free build.
Then we can turn "warnings as errors" on.

[jingham]

It looks like clang-format wasn't run over this file as it was over all the main lldb sources in the infamous universal code reformatting. That seems odd.

Anyway, it might be better just to do that to this file using the top level .clang-format. Note that you are making several choices which were not the choices made by clang-format using the .clang-format file that was used to implement this reformatting. We probably shouldn't revise that decision piecemeal.

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

32–43

This change seems a shame, the original was much easier to read.

62–66

clang-format moved the initial { for functions into the function definition line universally when it was run over the lldb sources. If we want to revise that decision, and go back to the initial function curly starting a line, that would be fine by me, but I don't think we should do it piecemeal.

Ditto for separating the return type & function name onto separate lines. That was the way we did it originally, but the clang-format style that was chosen for the reformatting undid that. I much prefer the way you changed it to here, but that's a decision we should make globally, not file by file.

[jingham]

Actually, we didn't run the clang-format over the test case source files, since we didn't want to have to deal with the possible failures resulting. So just clang-formatting this file is probably the right way to go.

[eugene]

In D30234#683018, @jingham wrote:

Anyway, it might be better just to do that to this file using the top level .clang-format. Note that you are making several choices which were not the choices made by clang-format using the .clang-format file that was used to implement this reformatting. We probably shouldn't revise that decision piecemeal.

It wasn't my intention to revise any formatting decisions made earlier.
I just ran 'clang-format -style=file -i main.cpp' assuming that it will actually make the file complaint with the lldb's coding style by using top level .clang-format.

Is there any document other than http://llvm.org/docs/CodingStandards.html describing LLDB coding conventions?

[eugene]

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

32–43

Agree. But I think consistency is better than beauty in case of code formatting.

62–66

Could you please elaborate.
I just ran 'clang-format -style=file -i main.cpp' assuming that it will actually make the file complaint with the lldb's coding style by using top level .clang-format.

[krytarowski]

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

74

Note to self -

#elif defined(__NetBSD__)
printf("%" PRIx64, static_cast<uint64_t>(_lwp_self()));

and include

#if defined(__NetBSD__)
#include <lwp.h>
#endif

[labath]

clang-format did not pick up the correct formatting because we have a .clang-format file in packages/Python/lldbsuite. This was necessary because a lot of the tests would get broken, as the formatting would break our // place breakpoint here annotations (also, stepping behavior is affected by the line breaks). It would be an interesting project to format all existing tests, but this would probably need to be done on a test-by-test basis (and may involve adding additional clang-format directives like CommentPragmas, ...).

That said, none of these problems should apply to lldb-server tests as they operate differently, so reformatting them is probably a good idea. I guess you should also then put a .clang-format file in the lldb-server test folder to make sure it stays formatted in the future.

[eugene]

I have added local .clang-format file. But it didn't change the way main.cpp was formated.

[labath]

In D30234#683880, @eugene wrote:

I have added local .clang-format file. But it didn't change the way main.cpp was formated.

That's fine, I did not expect that to make a difference now. What it will do though, is make sure that any subsequent modifications conform to the formatting rules (if one runs e.g. "git clang-format"). Without this, it would pick up the .clang_format file in the parent test folder which says "don't touch anything".

LGTM.

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 <cstring>
 #include <errno.h>
 #include <inttypes.h>
 #include <memory>
 #include <pthread.h>
 #include <setjmp.h>
 #include <signal.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <string.h>
 #include <time.h>
 #include <unistd.h>
 #include <vector>
 
 #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";
 static const char *const THREAD_COMMAND_PRINT_IDS = "print-ids";
 static const char *const THREAD_COMMAND_SEGFAULT = "segfault";
 
 static bool g_print_thread_ids = false;
 static pthread_mutex_t g_print_mutex = PTHREAD_MUTEX_INITIALIZER;
 static bool g_threads_do_segfault = false;
 
 static pthread_mutex_t g_jump_buffer_mutex = PTHREAD_MUTEX_INITIALIZER;
 static jmp_buf g_jump_buffer;
 static bool g_is_segfaulting = false;
 
 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 if we're one of the expected signal handlers.
+  switch (signo) {
+    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).
+    }
+    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).
+  }
 
-  // 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);
-  }
+  // 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';
+static void swap_chars() {
 
-    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 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;
+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);
+  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_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);
+  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);
+    // 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);
-  }
+    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);
-  }
+  int sleep_seconds_remaining = 60;
+  while (sleep_seconds_remaining > 0) {
+    sleep_seconds_remaining = sleep(sleep_seconds_remaining);
+  }
 
-  return nullptr;
+  return nullptr;
 }
 
-int main (int argc, char **argv)
-{
-  lldb_enable_attach();
+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;
+  std::vector<pthread_t> threads;
+  std::unique_ptr<uint8_t[]> heap_array_up;
 
-  // 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);
-  }
+  // 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(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);
-  }
+  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));
+  // Process command line args.
+  for (int i = 1; i < argc; ++i) {
+    if (std::strstr(argv[i], STDERR_PREFIX)) {
+      fprintf(stderr, "%s\n", (argv[i] + strlen(STDERR_PREFIX)));
+    } else if (std::strstr(argv[i], RETVAL_PREFIX)) {
+      return_value = std::atoi(argv[i] + strlen(RETVAL_PREFIX));
+    } else if (std::strstr(argv[i], 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
-      // 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));
+      // 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';
+      // 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;
+    } 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)) {
 
-            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;
+      if (std::strstr(argv[i] + strlen(GET_DATA_ADDRESS_PREFIX), "g_message"))
+      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_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("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;
+      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)) {
 
-            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;
+      if (std::strstr(argv[i] + strlen(GET_CODE_ADDRESS_PREFIX), "hello"))
+      else if (std::strstr(argv[i] + strlen(GET_CODE_ADDRESS_PREFIX),
+                           "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;
+      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)) {
+      if (std::strcmp(argv[i] + strlen(CALL_FUNCTION_PREFIX), "hello") == 0)
+      else if (std::strcmp(argv[i] + strlen(CALL_FUNCTION_PREFIX),
+                           "swap_chars") == 0)
+      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]);
-        }
-    }
+        // 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 {
 
-  // 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;
+  // 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);
+      fprintf(stderr, "pthread_join() failed with error code %d\n", err);
+  }
 }