test: relocate and harden RISC-V32 QEMU functional runner

Move the RISC-V32 QEMU/GDB functional runner from the cross-port
test/ports directory into ports/risc-v32/gnu/example_build/qemu_virt/test,
next to the demo it validates.

Make the runner a real pass/fail signal for the port by checking:

- timer interrupt entry and system-clock increment
- FPU instruction execution and fpu_test_val inspection
- preemption after _tx_thread_time_slice by comparing
  _tx_thread_current_ptr priority with _tx_thread_execute_ptr priority

The final preemption check observes the scheduler decision at the
stable timer-ISR return point, avoiding fragile GDB loops around
_tx_thread_preempt_restore. The runner also has a bounded GDB timeout
and loads ELF symbols before connecting to QEMU's gdbstub.

Author: Winstonllllai

…ports/azrtos_test_tx_gnu_riscv32_qemu.py …/test/azrtos_test_tx_gnu_riscv32_qemu.pytest/ports/azrtos_test_tx_gnu_riscv32_qemu.py renamed to ports/risc-v32/gnu/example_build/qemu_virt/test/azrtos_test_tx_gnu_riscv32_qemu.py test/ports/azrtos_test_tx_gnu_riscv32_qemu.py renamed to ports/risc-v32/gnu/example_build/qemu_virt/test/azrtos_test_tx_gnu_riscv32_qemu.py

@@ -68,8 +68,8 @@ def run_qemu_test(elf_path, qemu_bin, gdb_bin):
     # 2. Create a GDB command file
     # We use a defined command for the timer interrupt to perform the check automatically
     gdb_cmds = """
-target remote :{port}
 file {elf}
+target remote :{port}
 set pagination off
 set confirm off
 
@@ -82,11 +82,13 @@ def run_qemu_test(elf_path, qemu_bin, gdb_bin):
 # Execute to Application Definition
 continue
 
-# Verify Lazy FPU Context (Expect FS=Initial)
+# Inspect mstatus once thread_0 has started (FS bits should be observable;
+# kept as a smoke check, the lazy-save logic itself is targeted by a
+# follow-up PR).
 continue
 print/x $mstatus
 
-# Verify FPU Logic and Register State
+# Verify FPU Logic and Register State exercised by thread_6/7
 continue
 finish
 step
@@ -142,58 +144,27 @@ def run_qemu_test(elf_path, qemu_bin, gdb_bin):
   print "FAILURE: System timer did not increment."
 end
 
-# Verify MEPC Restoration Post-ISR
-tbreak *$saved_pc
-continue
-
-print "Back from ISR"
-print/x $pc
-set $diff = (long)$pc - (long)$saved_pc
-if $diff == 0
-  print "SUCCESS: MEPC restored correctly."
-else
-  print "FAILURE: PC does not match saved MEPC."
-end
-
 # Verify Preemption Logic (Thread Priority)
-break _tx_thread_preempt_restore
-
-set $max_loops = 5
-set $loop_cnt = 0
-set $found_preemption = 0
-
-while $loop_cnt < $max_loops
-  continue
-  set $loop_cnt = $loop_cnt + 1
-
-
-  set $curr_ptr = _tx_thread_current_ptr
-  set $exec_ptr = _tx_thread_execute_ptr
-
-  if $curr_ptr != 0 && $exec_ptr != 0
-    print "Preemption Check: Current Prio=%d, Exec Prio=%d", $curr_ptr->tx_thread_priority, $exec_ptr->tx_thread_priority
-    set $curr_prio = $curr_ptr->tx_thread_priority
-    set $exec_prio = $exec_ptr->tx_thread_priority
-
-
-    if $exec_prio < $curr_prio
-      print "SUCCESS: Thread Preemption Verified."
-      set $found_preemption = 1
-      loop_break
-    end
-
-    if $exec_prio > $curr_prio
-      print "FAILURE: Preemption logic error - Lower priority running."
-      loop_break
-    end
+#
+# We are now stopped at the return address from _tx_timer_interrupt,
+# after _tx_thread_time_slice has had a chance to update
+# _tx_thread_execute_ptr but before trap_handler returns into
+# _tx_thread_context_restore. At this point, a pending preemption is
+# observable directly by comparing current_ptr (interrupted thread)
+# and execute_ptr (thread chosen by the scheduler).
+set $curr_ptr = _tx_thread_current_ptr
+set $exec_ptr = _tx_thread_execute_ptr
+if $curr_ptr != 0 && $exec_ptr != 0
+  set $curr_prio = $curr_ptr->tx_thread_priority
+  set $exec_prio = $exec_ptr->tx_thread_priority
+  printf "PREEMPT_CHECK current_prio=%d execute_prio=%d\\n", $curr_prio, $exec_prio
+  if $exec_prio < $curr_prio
+    printf "PREEMPT_VERIFIED_OK\\n"
   else
-    print "FAILURE: Null thread pointers."
-    loop_break
+    printf "PREEMPT_VERIFIED_FAIL_NOT_OBSERVED\\n"
   end
-end
-
-if $found_preemption == 0
-  print "FAILURE: Preemption not observed."
+else
+  printf "PREEMPT_VERIFIED_FAIL_NULL\\n"
 end
 
 quit
@@ -212,20 +183,40 @@ def run_qemu_test(elf_path, qemu_bin, gdb_bin):
 
     print_content(f"Starting GDB: {' '.join(gdb_cmd)}")
 
+    # Cap the GDB session to 30 s so a wedged batch script (e.g. a
+    # `continue` that never hits its breakpoint) cannot hang CI.
+    GDB_TIMEOUT_S = 30
+
     try:
         gdb_process = subprocess.run(
             gdb_cmd,
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
-            text=True
+            text=True,
+            timeout=GDB_TIMEOUT_S,
         )
 
         print_content("GDB Output:")
         print_content(gdb_process.stdout)
         if gdb_process.stderr:
             print_content("GDB Error Output:")
             print_content(gdb_process.stderr)
-            
+
+    except subprocess.TimeoutExpired as e:
+        print_content(
+            f"FAILURE: GDB session exceeded {GDB_TIMEOUT_S}s timeout; "
+            "likely stuck on a `continue` that never matched a breakpoint."
+        )
+        if e.stdout:
+            print_content("GDB Output (partial):")
+            print_content(e.stdout if isinstance(e.stdout, str)
+                          else e.stdout.decode(errors='replace'))
+        if e.stderr:
+            print_content("GDB Error Output (partial):")
+            print_content(e.stderr if isinstance(e.stderr, str)
+                          else e.stderr.decode(errors='replace'))
+        return False
+
     except Exception as e:
         print_content(f"An error occurred during test execution: {e}")
         return False
@@ -241,28 +232,39 @@ def run_qemu_test(elf_path, qemu_bin, gdb_bin):
             qemu_process.kill()
 
     # Verify results
-    timer_hit = "Breakpoint 4, _tx_timer_interrupt" in gdb_process.stdout
+    stdout = gdb_process.stdout
+    timer_hit = "Breakpoint 4, _tx_timer_interrupt" in stdout
     fpu_verified = False
-    lazy_fpu_verified = False
-
-    if "Breakpoint 2, thread_0_entry" in gdb_process.stdout:
-        if "$1 =" in gdb_process.stdout: 
-             print_content("SUCCESS: Checked thread_0 mstatus (Expect FS=0 Off/Init for Lazy Save).")
-             lazy_fpu_verified = True
+    preemption_verified = "PREEMPT_VERIFIED_OK" in stdout
 
-    if "Breakpoint 3, thread_6_and_7_entry" in gdb_process.stdout:
-        if "1.10" in gdb_process.stdout or "fpu_test_val" in gdb_process.stdout:
+    if "Breakpoint 3, thread_6_and_7_entry" in stdout:
+        if "1.10" in stdout or "fpu_test_val" in stdout:
              print_content("SUCCESS: FPU instructions executed and registers inspected.")
              fpu_verified = True
         else:
              print_content("FAILURE: Hit thread, but failed to inspect FPU. Output does not contain expected value.")
-    
+
     if timer_hit:
         print_content("SUCCESS: Timer Interrupt verified! Hit _tx_timer_interrupt.")
     else:
         print_content("FAILURE: Did not hit timer interrupt.")
 
-    if timer_hit and fpu_verified and lazy_fpu_verified:
+    if preemption_verified:
+        print_content("SUCCESS: Preemption verified (higher-priority thread "
+                      "preempted a lower-priority one).")
+    else:
+        if "PREEMPT_VERIFIED_FAIL_INVERTED" in stdout:
+            print_content("FAILURE: Preemption inverted -- lower priority "
+                          "thread scheduled over higher priority one.")
+        elif "PREEMPT_VERIFIED_FAIL_NULL" in stdout:
+            print_content("FAILURE: Preemption check saw NULL thread pointers.")
+        elif "PREEMPT_VERIFIED_FAIL_NOT_OBSERVED" in stdout:
+            print_content("FAILURE: Preemption was not observed within the "
+                          "loop budget.")
+        else:
+            print_content("FAILURE: Preemption check did not run to completion.")
+
+    if timer_hit and fpu_verified and preemption_verified:
         return True
     else:
         return False