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

This patch is rearranging code a bit to add WatchpointResources to
Process. A WatchpointResource is meant to represent a hardware
watchpoint register in the inferior process. It has an address, a size,
a type, and a list of Watchpoints that are using this
WatchpointResource.

This current patch doesn't add any of the features of
WatchpointResources that make them interesting -- a user asking to watch
a 24 byte object could watch this with three 8 byte WatchpointResources.
Or a Watchpoint on 1 byte at 0x1002 and a second watchpoint on 1 byte at
0x1003, these must both be served by a single WatchpointResource on that
doubleword at 0x1000 on a 64-bit target, if two hardware watchpoint
registers were used to track these separately, one of them may not be
hit. Or if you have one Watchpoint on a variable with a condition set,
and another Watchpoint on that same variable with a command defined or
different condition, or ignorecount, both of those Watchpoints need to
evaluate their criteria/commands when their WatchpointResource has been
hit.

There's a bit of code movement to rearrange things in the direction I'll
need for implementing this feature, so I want to start with reviewing &
landing this mostly NFC patch and we can focus on the algorithmic
choices about how WatchpointResources are shared and handled as they're
triggeed, separately.

This patch also stops printing "Watchpoint <n> hit: old value: <x>, new
vlaue: <y>" for Read watchpoints. I could make an argument for print
"Watchpoint <n> hit: current value <x>" but the current output doesn't
make any sense, and the user can print the value if they are
particularly interested. Read watchpoints are used primarily to
understand what code is reading a variable.

This patch adds more fallbacks for how to print the objects being
watched if we have types, instead of assuming they are all integral
values, so a struct will print its elements. As large watchpoints are
added, we'll be doing a lot more of those.

To track the WatchpointSP in the WatchpointResources, I changed the
internal API which took a WatchpointSP and devolved it to a Watchpoint*,
which meant touching several different Process files. I removed the
watchpoint code in ProcessKDP which only reported that watchpoints
aren't supported, the base class does that already.

I haven't yet changed how we receive a watchpoint to identify the
WatchpointResource responsible for the trigger, and identify all
Watchpoints that are using this Resource to evaluate their conditions
etc. This is the same work that a BreakpointSite needs to do when it has
been tiggered, where multiple Breakpoints may be at the same address.

There is not yet any printing of the Resources that a Watchpoint is
implemented in terms of ("watchpoint list", or
SBWatchpoint::GetDescription).

"watchpoint set var" and "watchpoint set expression" take a size
argument which was previously 1, 2, 4, or 8 (an enum). I've changed this
to an unsigned int. Most hardware implementations can only watch 1, 2,
4, 8 byte ranges, but with Resources we'll allow a user to ask for
different sized watchpoints and set them in hardware-expressble terms
soon.

I've annotated areas where I know there is work still needed with
LWP_TODO that I'll be working on once this is landed.

I've tested this on aarch64 macOS, aarch64 Linux, and Intel macOS.

https://discourse.llvm.org/t/rfc-large-watchpoint-support-in-lldb/72116
(cherry picked from commit fc6b725)

Author: jasonmolenda

lldb/include/lldb/Breakpoint/BreakpointSite.h

@@ -45,6 +45,9 @@ 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
@@ -77,8 +80,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 owners, it should just get removed.  This
-  /// enable/disable is for the low-level target code to enable and disable
+  /// 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 sites when single stepping, etc.
   bool IsEnabled() const;
 
@@ -101,44 +104,46 @@ class BreakpointSite : public std::enable_shared_from_this<BreakpointSite>,
   /// Standard Dump method
   void Dump(Stream *s) const override;
 
-  /// The "Owners" are the breakpoint locations that share this breakpoint
-  /// site. The method adds the \a owner to this breakpoint site's owner list.
+  /// The "Constituents" are the breakpoint locations that share this breakpoint
+  /// site. The method adds the \a constituent to this breakpoint site's
+  /// constituent list.
   ///
-  /// \param[in] owner
-  ///    \a owner is the Breakpoint Location to add.
-  void AddOwner(const lldb::BreakpointLocationSP &owner);
+  /// \param[in] constituent
+  ///    \a constituent is the Breakpoint Location to add.
+  void AddConstituent(const lldb::BreakpointLocationSP &constituent);
 
   /// This method returns the number of breakpoint locations currently located
   /// at this breakpoint site.
   ///
   /// \return
-  ///    The number of owners.
-  size_t GetNumberOfOwners();
+  ///    The number of constituents.
+  size_t GetNumberOfConstituents();
 
   /// This method returns the breakpoint location at index \a index located at
-  /// this breakpoint site.  The owners are listed ordinally from 0 to
-  /// GetNumberOfOwners() - 1 so you can use this method to iterate over the
-  /// owners
+  /// this breakpoint site.  The constituents are listed ordinally from 0 to
+  /// GetNumberOfConstituents() - 1 so you can use this method to iterate over
+  /// the constituents
   ///
   /// \param[in] idx
-  ///     The index in the list of owners for which you wish the owner location.
+  ///     The index in the list of constituents for which you wish the
+  ///     constituent location.
   ///
   /// \return
   ///    A shared pointer to the breakpoint location at that index.
-  lldb::BreakpointLocationSP GetOwnerAtIndex(size_t idx);
+  lldb::BreakpointLocationSP GetConstituentAtIndex(size_t idx);
 
-  /// This method copies the breakpoint site's owners into a new collection.
-  /// It does this while the owners mutex is locked.
+  /// This method copies the breakpoint site's constituents into a new
+  /// collection. It does this while the constituents mutex is locked.
   ///
   /// \param[out] out_collection
-  ///    The BreakpointLocationCollection into which to put the owners
+  ///    The BreakpointLocationCollection into which to put the constituents
   ///    of this breakpoint site.
   ///
   /// \return
   ///    The number of elements copied into out_collection.
-  size_t CopyOwnersList(BreakpointLocationCollection &out_collection);
+  size_t CopyConstituentsList(BreakpointLocationCollection &out_collection);
 
-  /// Check whether the owners of this breakpoint site have any thread
+  /// Check whether the constituents of this breakpoint site have any thread
   /// specifiers, and if yes, is \a thread contained in any of these
   /// specifiers.
   ///
@@ -151,7 +156,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 owners. Use
+  /// GetDescription tells you about the breakpoint site's constituents. Use
   /// BreakpointSite::Dump(Stream *) to get information about the breakpoint
   /// site itself.
   ///
@@ -203,9 +208,10 @@ class BreakpointSite : public std::enable_shared_from_this<BreakpointSite>,
 
   void BumpHitCounts();
 
-  /// The method removes the owner at \a break_loc_id from this breakpoint
+  /// The method removes the constituent at \a break_loc_id from this breakpoint
   /// list.
-  size_t RemoveOwner(lldb::break_id_t break_id, lldb::break_id_t break_loc_id);
+  size_t RemoveConstituent(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
@@ -215,20 +221,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 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.
+  // 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.
 
   static lldb::break_id_t GetNextID();
 
   // Only the Process can create breakpoint sites in
   // Process::CreateBreakpointSite (lldb::BreakpointLocationSP &, bool).
-  BreakpointSite(BreakpointSiteList *list,
-                 const lldb::BreakpointLocationSP &owner, lldb::addr_t m_addr,
-                 bool use_hardware);
+  BreakpointSite(const lldb::BreakpointLocationSP &constituent,
+                 lldb::addr_t m_addr, bool use_hardware);
 
   BreakpointSite(const BreakpointSite &) = delete;
   const BreakpointSite &operator=(const BreakpointSite &) = delete;