nvdrv: Switch 2 GPU address-space layout; gpu 33/203

- AllocAsEx from Switch 2 NvRm passes flags 5, no big page size, range
  [0x8000000, 0xC000000000) and split 0 (small pages only). Treat split 0
  as small pages up to the end, keep a 4 GiB big-page region after it, and
  give that allocator an absolute limit (Eden's length-as-limit breaks once
  the split is past the region length).
- gpu TIPC 33 returns a count, 203 a kind plus a VA range used by
  nn::gpu::sdk::CreateGpuAddressSpace.
- gdbrsp.py: unbreak, step, breaklr, unbreakpc, fp (frame walk), trace.

1 files changed, 39 insertions, 1 deletions

diff --git a/tools/nx2/gdbrsp.py b/tools/nx2/gdbrsp.py
index 03ffbd00f5..ba81c33c1a 100644
--- a/tools/nx2/gdbrsp.py
+++ b/tools/nx2/gdbrsp.py
@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 # Minimal GDB remote-serial-protocol client for Eden's gdbstub (AArch64 guests).
 # Usage: gdbrsp.py <port> <script>
-# Script lines:  break <hexaddr> | unbreak <hexaddr> | continue | regs | mem <hexaddr|xN> <len> | bt <hexaddr|sp> <count>
+# Script lines:  break <hexaddr> | unbreak <hexaddr> | continue | regs | x0 | mem <hexaddr|xN> <len> | bt <hexaddr|sp> <count>
 #                | quit
 import socket
 import struct
@@ -76,10 +76,36 @@ def main():
         op = parts[0]
         if op == "break":
             print("break", parts[1], "->", rsp.cmd(f"Z0,{int(parts[1], 16):x},4"))
+        elif op == "breaklr":
+            # Break at the current return address (x30 from the last regs/x0).
+            lr = regs.get("x30", 0) & 0xFFFFFFFFFFFF
+            print("breaklr", hex(lr), "->", rsp.cmd(f"Z0,{lr:x},4"))
+        elif op == "unbreakpc":
+            pc = regs.get("pc", 0)
+            print("unbreakpc", hex(pc), "->", rsp.cmd(f"z0,{pc:x},4"))
         elif op == "unbreak":
             print("unbreak", parts[1], "->", rsp.cmd(f"z0,{int(parts[1], 16):x},4"))
+        elif op == "step":
+            print("step:", rsp.cmd("s"))
+        elif op == "trace":
+            # Single-step N instructions, printing pc and x0 (stop early at an optional pc).
+            n = int(parts[1])
+            stop_at = int(parts[2], 16) if len(parts) > 2 else None
+            lo = int(parts[3], 16) if len(parts) > 4 else 0
+            hi = int(parts[4], 16) if len(parts) > 4 else 1 << 64
+            for _ in range(n):
+                rsp.cmd("s")
+                r = rsp.regs()
+                if lo <= r["pc"] < hi:
+                    print(f"  t pc={r['pc']:#x} x0={r['x0']:#x} x8={r['x8']:#x}")
+                if stop_at is not None and r["pc"] == stop_at:
+                    break
         elif op == "continue":
             print("stop:", rsp.cmd("c"))
+        elif op == "x0":
+            r = rsp.regs()
+            regs = r
+            print(f"  pc={r.get('pc', 0):#x} x0={r.get('x0', 0):#x} x1={r.get('x1', 0):#x} lr={r.get('x30', 0):#x}")
         elif op == "regs":
             regs = rsp.regs()
             print(" ".join(f"{k}={v:#x}" for k, v in regs.items()))
@@ -89,6 +115,18 @@ def main():
             for i in range(0, len(data), 16):
                 words = [struct.unpack_from("<Q", data, i + j)[0] for j in range(0, min(16, len(data) - i) - 7, 8)]
                 print(f"  {a + i:#x}: " + " ".join(f"{w:016x}" for w in words))
+        elif op == "fp":
+            # Walk the frame-pointer chain: print return addresses.
+            fp = regs.get("x29", 0)
+            for _ in range(int(parts[1]) if len(parts) > 1 else 12):
+                d = rsp.mem(fp, 16)
+                if len(d) < 16:
+                    break
+                nfp, ret = struct.unpack("<QQ", d)
+                print(f"  frame fp={fp:#x} ret={ret & 0xFFFFFFFFFFFF:#x}")
+                if nfp <= fp:
+                    break
+                fp = nfp
         elif op == "quit":
             break
     rsp.s.close()