1 //===-- WatchpointResource.h ------------------------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #ifndef LLDB_BREAKPOINT_WATCHPOINTRESOURCE_H 10 #define LLDB_BREAKPOINT_WATCHPOINTRESOURCE_H 11 12 #include "lldb/Utility/Iterable.h" 13 #include "lldb/lldb-public.h" 14 15 #include <mutex> 16 #include <vector> 17 18 namespace lldb_private { 19 20 class WatchpointResource 21 : public std::enable_shared_from_this<WatchpointResource> { 22 23 public: 24 WatchpointResource(lldb::addr_t addr, size_t size, bool read, bool write); 25 26 ~WatchpointResource(); 27 28 typedef lldb::wp_resource_id_t SiteID; 29 typedef lldb::watch_id_t ConstituentID; 30 31 lldb::addr_t GetLoadAddress() const; 32 33 size_t GetByteSize() const; 34 35 bool WatchpointResourceRead() const; 36 37 bool WatchpointResourceWrite() const; 38 39 void SetType(bool read, bool write); 40 41 typedef std::vector<lldb::WatchpointSP> WatchpointCollection; 42 typedef LockingAdaptedIterable<WatchpointCollection, lldb::WatchpointSP, 43 vector_adapter, std::mutex> 44 WatchpointIterable; 45 46 /// Iterate over the watchpoint constituents for this resource 47 /// 48 /// \return 49 /// An Iterable object which can be used to loop over the watchpoints 50 /// that are constituents of this resource. Constituents()51 WatchpointIterable Constituents() { 52 return WatchpointIterable(m_constituents, m_constituents_mutex); 53 } 54 55 /// Enquires of the atchpoints that produced this watchpoint resource 56 /// whether we should stop at this location. 57 /// 58 /// \param[in] context 59 /// This contains the information about this stop. 60 /// 61 /// \return 62 /// \b true if we should stop, \b false otherwise. 63 bool ShouldStop(StoppointCallbackContext *context); 64 65 /// Standard Dump method 66 void Dump(Stream *s) const; 67 68 /// The "Constituents" are the watchpoints that share this resource. 69 /// The method adds the \a constituent to this resource's constituent list. 70 /// 71 /// \param[in] constituent 72 /// \a constituent is the Wachpoint to add. 73 void AddConstituent(const lldb::WatchpointSP &constituent); 74 75 /// The method removes the constituent at \a constituent from this watchpoint 76 /// resource. 77 void RemoveConstituent(lldb::WatchpointSP &constituent); 78 79 /// This method returns the number of Watchpoints currently using 80 /// watchpoint resource. 81 /// 82 /// \return 83 /// The number of constituents. 84 size_t GetNumberOfConstituents(); 85 86 /// This method returns the Watchpoint at index \a index using this 87 /// Resource. The constituents are listed ordinally from 0 to 88 /// GetNumberOfConstituents() - 1 so you can use this method to iterate over 89 /// the constituents. 90 /// 91 /// \param[in] idx 92 /// The index in the list of constituents for which you wish the 93 /// constituent location. 94 /// 95 /// \return 96 /// The Watchpoint at that index. 97 lldb::WatchpointSP GetConstituentAtIndex(size_t idx); 98 99 /// Check if the constituents includes a watchpoint. 100 /// 101 /// \param[in] wp_sp 102 /// The WatchpointSP to search for. 103 /// 104 /// \result 105 /// true if this resource's constituents includes the watchpoint. 106 bool ConstituentsContains(const lldb::WatchpointSP &wp_sp); 107 108 /// Check if the constituents includes a watchpoint. 109 /// 110 /// \param[in] wp 111 /// The Watchpoint to search for. 112 /// 113 /// \result 114 /// true if this resource's constituents includes the watchpoint. 115 bool ConstituentsContains(const lldb_private::Watchpoint *wp); 116 117 /// This method copies the watchpoint resource's constituents into a new 118 /// collection. It does this while the constituents mutex is locked. 119 /// 120 /// \return 121 /// A copy of the Watchpoints which own this resource. 122 WatchpointCollection CopyConstituentsList(); 123 124 lldb::wp_resource_id_t GetID() const; 125 126 bool Contains(lldb::addr_t addr); 127 128 protected: 129 // The StopInfoWatchpoint knows when it is processing a hit for a thread for 130 // a site, so let it be the one to manage setting the location hit count once 131 // and only once. 132 friend class StopInfoWatchpoint; 133 134 void BumpHitCounts(); 135 136 private: 137 static lldb::wp_resource_id_t GetNextID(); 138 139 lldb::wp_resource_id_t m_id; 140 141 // Start address & size aligned & expanded to be a valid watchpoint 142 // memory granule on this target. 143 lldb::addr_t m_addr; 144 size_t m_size; 145 146 bool m_watch_read; 147 bool m_watch_write; 148 149 /// The Watchpoints which own this resource. 150 WatchpointCollection m_constituents; 151 152 /// This mutex protects the constituents collection. 153 std::mutex m_constituents_mutex; 154 155 WatchpointResource(const WatchpointResource &) = delete; 156 const WatchpointResource &operator=(const WatchpointResource &) = delete; 157 }; 158 159 } // namespace lldb_private 160 161 #endif // LLDB_BREAKPOINT_WATCHPOINTRESOURCE_H 162