[lldb][AArch64] Use atomics to sync threads in SVE threading test

[DavidSpickett]

Summary

Previously we would "process continue" then wait for the number of
threads to be 3 before proceeding with the test.

Testing this on QEMU I saw it would sometimes get stuck at this check,
with one of the threads on a breakpoint before the other had started.
We do want it to be on a breakpoint, but we need the other thread to have
at least started so lldb can interact with both.

I've also seen it timeout on the Graviton buildbot, likely the same
cause.

To fix this add 2 variables to stall either thread until the other
has started up. Then it doesn't matter which one hits its breakpoint
first, the test will just continue the one that didn't, until both
are on the expected breakpoint.

[DavidSpickett]

One recent example of a timeout on the Graviton bot: https://lab.llvm.org/buildbot/#/builders/96/builds/43649

[DavidSpickett]

I was not able to reproduce the bot's timeout situation with this or the previous implementation, but I did run this on a loop with stress in the background and didn't get any failures. I think doing it with atomics is at least in theory the proper way to do it regardless, even if it has its own corner cases that I haven't thought of.

[DavidSpickett]

Actually these don't need to be atomic. They aren't writing to the same locations
we just have one writer and one reader, and if the reader is delayed a bit it's
not a problem.

The volatile isn't needed at -O0 but might as well on the off chance something tries
to optimise it later.

[DavidSpickett]

The only way to know this truly works is to observe it on the bot for a while and I'm already piling too many reviews on Omair as it is. So I've gone ahead and landed this.

lldb/test/API/commands/register/register/aarch64_sve_registers/rw_access_dynamic_resize/TestSVEThreadedDynamic.py

def run_sve_test(self, mode):
 
         if 8 in supported_vg:
             self.check_sve_registers(8)
         else:
             self.check_sve_registers(4)
 
         self.runCmd("process continue", RUN_SUCCEEDED)
 
-        # If we start the checks too quickly, thread 3 may not have started.
-        while process.GetNumThreads() < 3:
-            pass
-
         for idx in range(1, process.GetNumThreads()):
             thread = process.GetThreadAtIndex(idx)
             if thread.GetStopReason() != lldb.eStopReasonBreakpoint:
                 self.runCmd("thread continue %d" % (idx + 1))
                 self.assertEqual(thread.GetStopReason(), lldb.eStopReasonBreakpoint)
 
             stopped_at_line_number = thread.GetFrameAtIndex(0).GetLineEntry().GetLine()
 

lldb/test/API/commands/register/register/aarch64_sve_registers/rw_access_dynamic_resize/main.c

 #include <pthread.h>
+#include <stdbool.h>
 #include <sys/prctl.h>
 
 #ifndef PR_SME_SET_VL
 #define PR_SME_SET_VL 63
 #endif
 
 #define SMSTART() asm volatile("msr  s0_3_c4_c7_3, xzr" /*smstart*/)
 
static inline void write_sve_registers() {
   asm volatile("cpy  z28.b, p0/z, #29\n\t");
   asm volatile("cpy  z29.b, p5/z, #30\n\t");
   asm volatile("cpy  z30.b, p10/z, #31\n\t");
   asm volatile("cpy  z31.b, p15/z, #32\n\t");
 }
 
 int SET_VL_OPT = PR_SVE_SET_VL;
 
+// These ensure that when lldb stops in one of threadX / threadY, the other has
+// at least been created. That means we can continue the other onto the expected
+// breakpoint. Otherwise we could get to the breakpoint in one thread before the
+// other has started.
+volatile bool threadX_ready = false;
+volatile bool threadY_ready = false;
+
 void *threadX_func(void *x_arg) {
+  threadX_ready = true;
+  while (!threadY_ready) {
+  }
+
   prctl(SET_VL_OPT, 8 * 4);
 #ifdef USE_SSVE
   SMSTART();
 #endif
   write_sve_registers();
   write_sve_registers(); // Thread X breakpoint 1
   return NULL;           // Thread X breakpoint 2
 }
 
 void *threadY_func(void *y_arg) {
+  threadY_ready = true;
+  while (!threadX_ready) {
+  }
+
   prctl(SET_VL_OPT, 8 * 2);
 #ifdef USE_SSVE
   SMSTART();
 #endif
   write_sve_registers();
   write_sve_registers(); // Thread Y breakpoint 1
   return NULL;           // Thread Y breakpoint 2
 }