Fix TestJoinAfterBreak test on Windows

[amccarth]

Summary

1. Converted the inferior to use <thread> so that it can compile cross-platform
2. Set a thread's state to eStateStopped when it's suspended.
3. Don't set the resume state in WillResume. That's just a hook for derived Thread classes to do bookkeeping.
4. Adjust the expectations in the test to match reality.

[zturner]

Do the multithreaded tests actually pass on Windows now after this, or do
they just get farther but fail on something else?

[amccarth]

The particular test this addresses now passes. The other one that I'd gotten working earlier (TestNumThreads) continues to pass.

The rest still fail to compile because they depend on pthreads, but I'm hopeful they will work once I convert them to std::threads, which is what I plan to attempt next.

[zturner]

test/functionalities/thread/break_after_join/TestBreakAfterJoin.py

81–86

If the STL is creating some magic threads behind the scenes in addition to the ones you requested, then I wonder if their orders will line up correctly. This might still fail if there are actually 7 threads, and the 7th one corresponds to one that actually hit the breakpoint.

Maybe a better check is something like:

threads_stopped = 0
for i in range(0, num_threads):
    thread = process.GetThreadAtIndex(i)
    if (thread.IsStopped())
        threads_stopped = threads_stopped + 1

self.assertEquals(threads_stopped, 6, "Incorrect number of threads stopped!")

[amccarth]

test/functionalities/thread/break_after_join/TestBreakAfterJoin.py

81–86

This might still fail if there are actually 7 threads, and the 7th one corresponds to one that actually hit the breakpoint.

Nope, they are all stopped when the breakpoint hits, so the number of stopped threads will be at least 6. In the case of Windows, it's 9, regardless of which one hits.

I could loop through all the threads and assert that they're stopped, but the test for the number of threads must be expressed as >= 6.

[amccarth]

Standby for a loop to check that the threads are stopped.

[amccarth]

Python loop to ensure all the threads are stopped at the breakpoint.

[zturner]

Ok, I get it. looks good

[Eugene.Zelenko]

Committed in rL238787.

source/Plugins/Process/Windows/TargetThreadWindows.cpp

 //===-- TargetThreadWindows.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/Core/Log.h"
+#include "lldb/Core/Logging.h"
+#include "lldb/Core/State.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/HostNativeThreadBase.h"
 #include "lldb/Host/windows/HostThreadWindows.h"
 #include "lldb/Host/windows/windows.h"
 #include "lldb/Target/RegisterContext.h"
 
 #include "TargetThreadWindows.h"
 #include "ProcessWindows.h"
+#include "ProcessWindowsLog.h"
 #include "UnwindLLDB.h"
 
 #if defined(_WIN64)
 #include "x64/RegisterContextWindows_x64.h"
 #else
 #include "x86/RegisterContextWindows_x86.h"
 #endif
 

 {
     DestroyThread();
 }
 
 void
 TargetThreadWindows::RefreshStateAfterStop()
 {
     ::SuspendThread(m_host_thread.GetNativeThread().GetSystemHandle());
-
+    SetState(eStateStopped);
     GetRegisterContext()->InvalidateIfNeeded(false);
 }
 
 void
 TargetThreadWindows::WillResume(lldb::StateType resume_state)
 {
-    SetResumeState(resume_state);
+    Log *log(lldb_private::GetLogIfAllCategoriesSet (WINDOWS_LOG_THREAD));
+    if (log)
+        log->Printf ("TargetThreadWindows::WillResume (tid = %" PRIi64 ") setting thread resume state to %s",
+                     GetID(), StateAsCString(resume_state));
 }
 
 void
 TargetThreadWindows::DidStop()
 {
 }
 
 RegisterContextSP

test/functionalities/thread/break_after_join/Makefile

 LEVEL = ../../../make
 
 CXX_SOURCES := main.cpp
-ENABLE_THREADS := YES
+ENABLE_STD_THREADS := YES
 include $(LEVEL)/Makefile.rules

test/functionalities/thread/break_after_join/TestBreakAfterJoin.py

def breakpoint_after_join_test(self):
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # This should create a breakpoint in the main thread.
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.breakpoint, num_expected_locations=1)
 
         # The breakpoint list should show 1 location.
         self.expect("breakpoint list -f", "Breakpoint location shown correctly",
-            substrs = ["1: file = 'main.cpp', line = %d, locations = 1" % self.breakpoint])
+            substrs = ["1: file = 'main.cpp', line = %d, exact_match = 0, locations = 1" % self.breakpoint])
 
         # Run the program.
         self.runCmd("run", RUN_FAILED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
             substrs = ['stopped',
                        'stop reason = breakpoint'])
 
         # Get the target process
         target = self.dbg.GetSelectedTarget()
         process = target.GetProcess()
 
         # The exit probably occured during breakpoint handling, but it isn't
         # guaranteed.  The main thing we're testing here is that the debugger
         # handles this cleanly is some way.
 
         # Get the number of threads
         num_threads = process.GetNumThreads()
 
-        # Make sure we see six threads
-        self.assertTrue(num_threads == 6, 'Number of expected threads and actual threads do not match.')
+        # Make sure we see at least six threads
+        self.assertTrue(num_threads >= 6, 'Number of expected threads and actual threads do not match.')
 
         # Get the thread objects
         thread1 = process.GetThreadAtIndex(0)
         thread2 = process.GetThreadAtIndex(1)
         thread3 = process.GetThreadAtIndex(2)
         thread4 = process.GetThreadAtIndex(3)
         thread5 = process.GetThreadAtIndex(4)
         thread6 = process.GetThreadAtIndex(5)
 
         # Make sure all threads are stopped
         self.assertTrue(thread1.IsStopped(), "Thread 1 didn't stop during breakpoint")
         self.assertTrue(thread2.IsStopped(), "Thread 2 didn't stop during breakpoint")
         self.assertTrue(thread3.IsStopped(), "Thread 3 didn't stop during breakpoint")
         self.assertTrue(thread4.IsStopped(), "Thread 4 didn't stop during breakpoint")
         self.assertTrue(thread5.IsStopped(), "Thread 5 didn't stop during breakpoint")
         self.assertTrue(thread6.IsStopped(), "Thread 6 didn't stop during breakpoint")
 
         # Run to completion
         self.runCmd("continue")
 
         # If the process hasn't exited, collect some information
         if process.GetState() != lldb.eStateExited:
             self.runCmd("thread list")
             self.runCmd("process status")

test/functionalities/thread/break_after_join/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.
 //
 //===----------------------------------------------------------------------===//
 
 // This test is intended to create a situation in which one thread will exit
 // while a breakpoint is being handled in another thread.  This may not always
 // happen because it's possible that the exiting thread will exit before the
 // breakpoint is hit.  The test case should be flexible enough to treat that
 // as success.
 
-#include <pthread.h>
-#include <unistd.h>
 #include <atomic>
+#include <chrono>
+#include <thread>
 
 volatile int g_test = 0;
 
 // Note that although hogging the CPU while waiting for a variable to change
 // would be terrible in production code, it's great for testing since it
 // avoids a lot of messy context switching to get multiple threads synchronized.
 #define do_nothing()  
 
 #define pseudo_barrier_wait(bar) \
     --bar;                       \
     while (bar > 0)              \
         do_nothing();
 
 #define pseudo_barrier_init(bar, count) (bar = count)
 
 // A barrier to synchronize all the threads.
 std::atomic_int g_barrier1;
 
 // A barrier to keep the threads from exiting until after the breakpoint has
 // been passed.
 std::atomic_int g_barrier2;
 
 void *
-break_thread_func (void *input)
+break_thread_func ()
 {
     // Wait until all the threads are running
     pseudo_barrier_wait(g_barrier1);
 
     // Wait for the join thread to join
-    usleep(50);
+    std::this_thread::sleep_for(std::chrono::microseconds(50));
 
     // Do something
     g_test++;       // Set breakpoint here
 
     // Synchronize after the breakpoint
     pseudo_barrier_wait(g_barrier2);
 
     // Return
     return NULL;
 }
 
 void *
-wait_thread_func (void *input)
+wait_thread_func ()
 {
     // Wait until the entire first group of threads is running
     pseudo_barrier_wait(g_barrier1);
 
     // Wait until the breakpoint has been passed
     pseudo_barrier_wait(g_barrier2);
 
     // Return
     return NULL;
 }
 
 void *
 join_thread_func (void *input)
 {
-    pthread_t *thread_to_join = (pthread_t*)input;
+    std::thread *thread_to_join = (std::thread *)input;
 
     // Sync up with the rest of the threads.
     pseudo_barrier_wait(g_barrier1);
 
     // Join the other thread
-    pthread_join(*thread_to_join, NULL);
+    thread_to_join->join();
 
     // Return
     return NULL;
 }
 
 int main ()
 {
-    pthread_t thread_1;
-    pthread_t thread_2;
-    pthread_t thread_3;
-    pthread_t thread_4;
-    pthread_t thread_5;
-
     // The first barrier waits for the non-joining threads to start.
     // This thread will also participate in that barrier.
     // The idea here is to guarantee that the joining thread will be
     // last in the internal list maintained by the debugger.
     pseudo_barrier_init(g_barrier1, 5);
 
     // The second barrier keeps the waiting threads around until the breakpoint
     // has been passed.
     pseudo_barrier_init(g_barrier2, 4);
 
     // Create a thread to hit the breakpoint
-    pthread_create (&thread_1, NULL, break_thread_func, NULL);
+    std::thread thread_1(break_thread_func);
 
     // Create more threads to slow the debugger down during processing.
-    pthread_create (&thread_2, NULL, wait_thread_func, NULL);
-    pthread_create (&thread_3, NULL, wait_thread_func, NULL);
-    pthread_create (&thread_4, NULL, wait_thread_func, NULL);
+    std::thread thread_2(wait_thread_func);
+    std::thread thread_3(wait_thread_func);
+    std::thread thread_4(wait_thread_func);
 
     // Create a thread to join the breakpoint thread
-    pthread_create (&thread_5, NULL, join_thread_func, &thread_4);
+    std::thread thread_5(join_thread_func, &thread_1);
 
     // Wait for the threads to finish
-    pthread_join(thread_5, NULL);
-    pthread_join(thread_4, NULL);
-    pthread_join(thread_3, NULL);
-    pthread_join(thread_2, NULL);
-    pthread_join(thread_1, NULL);
+    thread_5.join();  // implies thread_1 is already finished
+    thread_4.join();
+    thread_3.join();
+    thread_2.join();
 
     return 0;
 }