Revert "[lldb] [mostly NFC] Large WP foundation: WatchpointResources (#68845)"

...and follow ups.

As it has caused test failures on Linux Arm and AArch64:
https://lab.llvm.org/buildbot/#/builders/96/builds/49126
https://lab.llvm.org/buildbot/#/builders/17/builds/45824

```
  lldb-shell :: Subprocess/clone-follow-child-wp.test
  lldb-shell :: Subprocess/fork-follow-child-wp.test
  lldb-shell :: Subprocess/vfork-follow-child-wp.test
```

This reverts commit a6c62bf,
commit a0a1ff3 and commit
fc6b725.

Author: DavidSpickett

lldb/include/lldb/Breakpoint/BreakpointSite.h

@@ -45,9 +45,6 @@ class BreakpointSite : public std::enable_shared_from_this<BreakpointSite>,
                // display any breakpoint opcodes.
   };
 
-  typedef lldb::break_id_t SiteID;
-  typedef lldb::break_id_t ConstituentID;
-
   ~BreakpointSite() override;
 
   // This section manages the breakpoint traps
@@ -80,8 +77,8 @@ class BreakpointSite : public std::enable_shared_from_this<BreakpointSite>,
   /// Tells whether the current breakpoint site is enabled or not
   ///
   /// This is a low-level enable bit for the breakpoint sites.  If a
-  /// breakpoint site has no enabled constituents, it should just get removed.
-  /// This enable/disable is for the low-level target code to enable and disable
+  /// breakpoint site has no enabled owners, it should just get removed.  This
+  /// enable/disable is for the low-level target code to enable and disable
   /// breakpoint sites when single stepping, etc.
   bool IsEnabled() const;
 
@@ -104,46 +101,44 @@ class BreakpointSite : public std::enable_shared_from_this<BreakpointSite>,
   /// Standard Dump method
   void Dump(Stream *s) const override;
 
-  /// The "Constituents" are the breakpoint locations that share this breakpoint
-  /// site. The method adds the \a constituent to this breakpoint site's
-  /// constituent list.
+  /// The "Owners" are the breakpoint locations that share this breakpoint
+  /// site. The method adds the \a owner to this breakpoint site's owner list.
   ///
-  /// \param[in] constituent
-  ///    \a constituent is the Breakpoint Location to add.
-  void AddConstituent(const lldb::BreakpointLocationSP &constituent);
+  /// \param[in] owner
+  ///    \a owner is the Breakpoint Location to add.
+  void AddOwner(const lldb::BreakpointLocationSP &owner);
 
   /// This method returns the number of breakpoint locations currently located
   /// at this breakpoint site.
   ///
   /// \return
-  ///    The number of constituents.
-  size_t GetNumberOfConstituents();
+  ///    The number of owners.
+  size_t GetNumberOfOwners();
 
   /// This method returns the breakpoint location at index \a index located at
-  /// this breakpoint site.  The constituents are listed ordinally from 0 to
-  /// GetNumberOfConstituents() - 1 so you can use this method to iterate over
-  /// the constituents
+  /// this breakpoint site.  The owners are listed ordinally from 0 to
+  /// GetNumberOfOwners() - 1 so you can use this method to iterate over the
+  /// owners
   ///
   /// \param[in] idx
-  ///     The index in the list of constituents for which you wish the
-  ///     constituent location.
+  ///     The index in the list of owners for which you wish the owner location.
   ///
   /// \return
   ///    A shared pointer to the breakpoint location at that index.
-  lldb::BreakpointLocationSP GetConstituentAtIndex(size_t idx);
+  lldb::BreakpointLocationSP GetOwnerAtIndex(size_t idx);
 
-  /// This method copies the breakpoint site's constituents into a new
-  /// collection. It does this while the constituents mutex is locked.
+  /// This method copies the breakpoint site's owners into a new collection.
+  /// It does this while the owners mutex is locked.
   ///
   /// \param[out] out_collection
-  ///    The BreakpointLocationCollection into which to put the constituents
+  ///    The BreakpointLocationCollection into which to put the owners
   ///    of this breakpoint site.
   ///
   /// \return
   ///    The number of elements copied into out_collection.
-  size_t CopyConstituentsList(BreakpointLocationCollection &out_collection);
+  size_t CopyOwnersList(BreakpointLocationCollection &out_collection);
 
-  /// Check whether the constituents of this breakpoint site have any thread
+  /// Check whether the owners of this breakpoint site have any thread
   /// specifiers, and if yes, is \a thread contained in any of these
   /// specifiers.
   ///
@@ -156,7 +151,7 @@ class BreakpointSite : public std::enable_shared_from_this<BreakpointSite>,
   bool ValidForThisThread(Thread &thread);
 
   /// Print a description of this breakpoint site to the stream \a s.
-  /// GetDescription tells you about the breakpoint site's constituents. Use
+  /// GetDescription tells you about the breakpoint site's owners. Use
   /// BreakpointSite::Dump(Stream *) to get information about the breakpoint
   /// site itself.
   ///
@@ -208,10 +203,9 @@ class BreakpointSite : public std::enable_shared_from_this<BreakpointSite>,
 
   void BumpHitCounts();
 
-  /// The method removes the constituent at \a break_loc_id from this breakpoint
+  /// The method removes the owner at \a break_loc_id from this breakpoint
   /// list.
-  size_t RemoveConstituent(lldb::break_id_t break_id,
-                           lldb::break_id_t break_loc_id);
+  size_t RemoveOwner(lldb::break_id_t break_id, lldb::break_id_t break_loc_id);
 
   BreakpointSite::Type m_type; ///< The type of this breakpoint site.
   uint8_t m_saved_opcode[8]; ///< The saved opcode bytes if this breakpoint site
@@ -221,20 +215,20 @@ class BreakpointSite : public std::enable_shared_from_this<BreakpointSite>,
   bool
       m_enabled; ///< Boolean indicating if this breakpoint site enabled or not.
 
-  // Consider adding an optimization where if there is only one constituent, we
-  // don't store a list.  The usual case will be only one constituent...
-  BreakpointLocationCollection
-      m_constituents; ///< This has the BreakpointLocations
-                      /// that share this breakpoint site.
-  std::recursive_mutex m_constituents_mutex; ///< This mutex protects the
-                                             ///< constituents collection.
+  // Consider adding an optimization where if there is only one owner, we don't
+  // store a list.  The usual case will be only one owner...
+  BreakpointLocationCollection m_owners; ///< This has the BreakpointLocations
+                                         ///that share this breakpoint site.
+  std::recursive_mutex
+      m_owners_mutex; ///< This mutex protects the owners collection.
 
   static lldb::break_id_t GetNextID();
 
   // Only the Process can create breakpoint sites in
   // Process::CreateBreakpointSite (lldb::BreakpointLocationSP &, bool).
-  BreakpointSite(const lldb::BreakpointLocationSP &constituent,
-                 lldb::addr_t m_addr, bool use_hardware);
+  BreakpointSite(BreakpointSiteList *list,
+                 const lldb::BreakpointLocationSP &owner, lldb::addr_t m_addr,
+                 bool use_hardware);
 
   BreakpointSite(const BreakpointSite &) = delete;
   const BreakpointSite &operator=(const BreakpointSite &) = delete;

lldb/include/lldb/Breakpoint/BreakpointSiteList.h

@@ -0,0 +1,173 @@
+//===-- BreakpointSiteList.h ------------------------------------*- C++ -*-===//
+//
+// 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_BREAKPOINT_BREAKPOINTSITELIST_H
+#define LLDB_BREAKPOINT_BREAKPOINTSITELIST_H
+
+#include <functional>
+#include <map>
+#include <mutex>
+
+#include "lldb/Breakpoint/BreakpointSite.h"
+
+namespace lldb_private {
+
+/// \class BreakpointSiteList BreakpointSiteList.h
+/// "lldb/Breakpoint/BreakpointSiteList.h" Class that manages lists of
+/// BreakpointSite shared pointers.
+class BreakpointSiteList {
+  // At present Process directly accesses the map of BreakpointSites so it can
+  // do quick lookups into the map (using GetMap).
+  // FIXME: Find a better interface for this.
+  friend class Process;
+
+public:
+  /// Default constructor makes an empty list.
+  BreakpointSiteList();
+
+  /// Destructor, currently does nothing.
+  ~BreakpointSiteList();
+
+  /// Add a BreakpointSite to the list.
+  ///
+  /// \param[in] bp_site_sp
+  ///    A shared pointer to a breakpoint site being added to the list.
+  ///
+  /// \return
+  ///    The ID of the BreakpointSite in the list.
+  lldb::break_id_t Add(const lldb::BreakpointSiteSP &bp_site_sp);
+
+  /// Standard Dump routine, doesn't do anything at present. \param[in] s
+  ///     Stream into which to dump the description.
+  void Dump(Stream *s) const;
+
+  /// Returns a shared pointer to the breakpoint site at address \a addr.
+  ///
+  /// \param[in] addr
+  ///     The address to look for.
+  ///
+  /// \result
+  ///     A shared pointer to the breakpoint site. May contain a NULL
+  ///     pointer if no breakpoint site exists with a matching address.
+  lldb::BreakpointSiteSP FindByAddress(lldb::addr_t addr);
+
+  /// Returns a shared pointer to the breakpoint site with id \a breakID.
+  ///
+  /// \param[in] breakID
+  ///   The breakpoint site ID to seek for.
+  ///
+  /// \result
+  ///   A shared pointer to the breakpoint site.  May contain a NULL pointer if
+  ///   the
+  ///   breakpoint doesn't exist.
+  lldb::BreakpointSiteSP FindByID(lldb::break_id_t breakID);
+
+  /// Returns a shared pointer to the breakpoint site with id \a breakID -
+  /// const version.
+  ///
+  /// \param[in] breakID
+  ///   The breakpoint site ID to seek for.
+  ///
+  /// \result
+  ///   A shared pointer to the breakpoint site.  May contain a NULL pointer if
+  ///   the
+  ///   breakpoint doesn't exist.
+  const lldb::BreakpointSiteSP FindByID(lldb::break_id_t breakID) const;
+
+  /// Returns the breakpoint site id to the breakpoint site at address \a
+  /// addr.
+  ///
+  /// \param[in] addr
+  ///   The address to match.
+  ///
+  /// \result
+  ///   The ID of the breakpoint site, or LLDB_INVALID_BREAK_ID.
+  lldb::break_id_t FindIDByAddress(lldb::addr_t addr);
+
+  /// Returns whether the breakpoint site \a bp_site_id has \a bp_id
+  //  as one of its owners.
+  ///
+  /// \param[in] bp_site_id
+  ///   The breakpoint site id to query.
+  ///
+  /// \param[in] bp_id
+  ///   The breakpoint id to look for in \a bp_site_id.
+  ///
+  /// \result
+  ///   True if \a bp_site_id exists in the site list AND \a bp_id is one of the
+  ///   owners of that site.
+  bool BreakpointSiteContainsBreakpoint(lldb::break_id_t bp_site_id,
+                                        lldb::break_id_t bp_id);
+
+  void ForEach(std::function<void(BreakpointSite *)> const &callback);
+
+  /// Removes the breakpoint site given by \b breakID from this list.
+  ///
+  /// \param[in] breakID
+  ///   The breakpoint site index to remove.
+  ///
+  /// \result
+  ///   \b true if the breakpoint site \a breakID was in the list.
+  bool Remove(lldb::break_id_t breakID);
+
+  /// Removes the breakpoint site at address \a addr from this list.
+  ///
+  /// \param[in] addr
+  ///   The address from which to remove a breakpoint site.
+  ///
+  /// \result
+  ///   \b true if \a addr had a breakpoint site to remove from the list.
+  bool RemoveByAddress(lldb::addr_t addr);
+
+  bool FindInRange(lldb::addr_t lower_bound, lldb::addr_t upper_bound,
+                   BreakpointSiteList &bp_site_list) const;
+
+  typedef void (*BreakpointSiteSPMapFunc)(lldb::BreakpointSiteSP &bp,
+                                          void *baton);
+
+  /// Enquires of the breakpoint site on in this list with ID \a breakID
+  /// whether we should stop for the breakpoint or not.
+  ///
+  /// \param[in] context
+  ///    This contains the information about this stop.
+  ///
+  /// \param[in] breakID
+  ///    This break ID that we hit.
+  ///
+  /// \return
+  ///    \b true if we should stop, \b false otherwise.
+  bool ShouldStop(StoppointCallbackContext *context, lldb::break_id_t breakID);
+
+  /// Returns the number of elements in the list.
+  ///
+  /// \result
+  ///   The number of elements.
+  size_t GetSize() const {
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
+    return m_bp_site_list.size();
+  }
+
+  bool IsEmpty() const {
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
+    return m_bp_site_list.empty();
+  }
+
+protected:
+  typedef std::map<lldb::addr_t, lldb::BreakpointSiteSP> collection;
+
+  collection::iterator GetIDIterator(lldb::break_id_t breakID);
+
+  collection::const_iterator GetIDConstIterator(lldb::break_id_t breakID) const;
+
+  mutable std::recursive_mutex m_mutex;
+  collection m_bp_site_list; // The breakpoint site list.
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_BREAKPOINT_BREAKPOINTSITELIST_H