[Lldb-commits] [lldb] [lldb] Add Policy infrastructure (PR #195762)

[Med Ismail Bennani via lldb-commits]

https://github.com/medismailben updated https://github.com/llvm/llvm-project/pull/195762

>From 4a2a333834be9984f5c5d156819ec75ae2324226 Mon Sep 17 00:00:00 2001
From: Med Ismail Bennani <ismail at bennani.ma>
Date: Mon, 4 May 2026 17:30:02 -0700
Subject: [PATCH] [lldb] Add Policy infrastructure

Add a generic thread-local policy stack and a Policy
struct that describes what view of the process a thread should see
(private reality vs public illusion) and what operations it is allowed
to perform.

This is the infrastructure for replacing ad-hoc host thread identity
checks (CurrentThreadIsPrivateStateThread, IsOnThread, etc.) with a
unified, composable mechanism. No behavioral changes yet -- adoption
will follow in subsequent patches.

rdar://176223894

Signed-off-by: Med Ismail Bennani <ismail at bennani.ma>
---
 lldb/include/lldb/Target/Policy.h             | 78 +++++++++++++++++++
 .../lldb/Utility/ThreadLocalPolicyStack.h     | 57 ++++++++++++++
 2 files changed, 135 insertions(+)
 create mode 100644 lldb/include/lldb/Target/Policy.h
 create mode 100644 lldb/include/lldb/Utility/ThreadLocalPolicyStack.h

diff --git a/lldb/include/lldb/Target/Policy.h b/lldb/include/lldb/Target/Policy.h
new file mode 100644
index 0000000000000..93bd5c39380f3
--- /dev/null
+++ b/lldb/include/lldb/Target/Policy.h
@@ -0,0 +1,78 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_TARGET_POLICY_H
+#define LLDB_TARGET_POLICY_H
+
+#include "lldb/Utility/ThreadLocalPolicyStack.h"
+
+namespace lldb_private {
+
+/// Describes what view of the process a thread should see and what
+/// operations it is allowed to perform.
+///
+/// Frame providers are a public illusion layered on top of the private
+/// reality (the unwinder stack). The private state thread manages the
+/// stop of that private reality, so the correct view for its logic IS the
+/// private reality. The public illusion is only applied once the process
+/// has settled and clients query the stopped state.
+///
+/// This struct is a pure data store -- no business logic. It is pushed
+/// onto a per-thread stack (PolicyStack) so that code
+/// can consult the current policy instead of comparing host thread
+/// identities.
+struct Policy {
+  /// What view of the process this thread sees.
+  enum class View {
+    Public,  // Provider-augmented frames, public state, public run lock.
+    Private, // Parent (unwinder) frames, private state, private run lock.
+  };
+
+  /// What operations this thread is allowed to perform.
+  /// Enforced at specific callsites, not by the policy itself.
+  struct Capabilities {
+    bool can_evaluate_expressions : 1;
+    bool stop_others_only : 1;
+    bool can_try_all_threads : 1;
+    bool can_run_breakpoint_actions : 1;
+    bool can_load_frame_providers : 1;
+    bool can_run_frame_recognizers : 1;
+  };
+
+  View view = View::Public;
+  Capabilities capabilities = {
+      true,  // can_evaluate_expressions
+      false, // stop_others_only
+      true,  // can_try_all_threads
+      true,  // can_run_breakpoint_actions
+      true,  // can_load_frame_providers
+      true,  // can_run_frame_recognizers
+  };
+
+  static Policy PublicState() { return {}; }
+
+  static Policy PrivateState() {
+    Policy p;
+    p.view = View::Private;
+    p.capabilities.can_load_frame_providers = false;
+    p.capabilities.can_run_frame_recognizers = false;
+    return p;
+  }
+
+  static Policy PublicStateRunningExpression() {
+    Policy p;
+    p.capabilities.can_run_breakpoint_actions = false;
+    return p;
+  }
+};
+
+using PolicyStack = ThreadLocalPolicyStack<Policy>;
+
+} // namespace lldb_private
+
+#endif // LLDB_TARGET_POLICY_H
diff --git a/lldb/include/lldb/Utility/ThreadLocalPolicyStack.h b/lldb/include/lldb/Utility/ThreadLocalPolicyStack.h
new file mode 100644
index 0000000000000..d24b23a34a583
--- /dev/null
+++ b/lldb/include/lldb/Utility/ThreadLocalPolicyStack.h
@@ -0,0 +1,57 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_UTILITY_THREADLOCALPOLICYSTACK_H
+#define LLDB_UTILITY_THREADLOCALPOLICYSTACK_H
+
+#include <vector>
+
+namespace lldb_private {
+
+/// Generic per-thread policy stack.
+///
+/// The stack lives in thread_local storage. Each thread has its own stack,
+/// initialized with a default-constructed base entry that is never popped.
+/// RAII guards (Guard) push and pop policies.
+///
+/// For thread pool workers that don't inherit thread_local storage, the
+/// policy must be passed into the lambda and pushed onto the worker
+/// thread's stack when the task starts.
+template <typename Policy> class ThreadLocalPolicyStack {
+public:
+  static ThreadLocalPolicyStack &GetForCurrentThread() {
+    static thread_local ThreadLocalPolicyStack s_stack;
+    return s_stack;
+  }
+
+  const Policy &Current() const { return m_stack.back(); }
+
+  void Push(Policy policy) { m_stack.push_back(policy); }
+
+  void Pop() {
+    if (m_stack.size() > 1)
+      m_stack.pop_back();
+  }
+
+  /// RAII guard that pushes a policy on construction and pops on destruction.
+  class Guard {
+  public:
+    Guard(Policy policy) { GetForCurrentThread().Push(policy); }
+    ~Guard() { GetForCurrentThread().Pop(); }
+
+    Guard(const Guard &) = delete;
+    Guard &operator=(const Guard &) = delete;
+  };
+
+private:
+  std::vector<Policy> m_stack = {Policy{}};
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_UTILITY_THREADLOCALPOLICYSTACK_H