This change contains changes that were made on a separate copy of this code,...

src/trusted/gdb_rsp/target.h

 /*
  * Copyright 2010 The Native Client Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can
  * be found in the LICENSE file.
  */
 
 
 // This module provides interfaces for accessing the debugging state of
 // the target.  The target can use either the thread that took the
 // exception or run in it's own thread.  To respond to the host, the
@@ skipping 30 matching lines @@
 
 class Target {
  public:
   enum ErrDef {
     NONE = 0,
     BAD_FORMAT = 1,
     BAD_ARGS = 2,
     FAILED = 3
   };
 
-  enum State {
-    UNINIT = 0,
-    RUNNING = 1,
-    STOPPED = 2
-  };
-
   typedef ErrDef (*QFunc_t)(Target *, stringvec&, std::string);
   typedef std::map<uint32_t, port::IThread*> ThreadMap_t;
   typedef std::map<std::string, std::string> PropertyMap_t;
   typedef std::map<uint64_t, uint8_t*> BreakMap_t;
 
- public:
   // Contruct a Target object.  By default use the native ABI.
   explicit Target(const Abi *abi = NULL);
   ~Target();
 
   // Init must be the first function called to correctlty
   // build the Target internal structures.
   bool Init();
 
+  // Set/Get locally cached properties
+  bool SetProperty(const std::string &name, const std::string& val);
+  bool GetProperty(const std::string &name, std::string* val) const;
+
+  // MatchQuery does a longest prefix match against the locally cached
+  // properties, and returns the length of the match, as well as the
+  // requested value.
+  size_t MatchQuery(const std::string& match, std::string* val) const;
+
   // Add and remove temporary breakpoints.  These breakpoints
   // must be added just before we start running, and removed
   // just before we stop running to prevent the debugger from
   // seeing the modified memory.
   bool AddTemporaryBreakpoint(uint64_t address);
   bool RemoveTemporaryBreakpoints();
 
   // This function should be called by a tracked thread when it takes
   // an exception.  It takes sig_start_ to prevent other exceptions
   // from signalling thread.  If wait is true, it will then  block on
   // sig_done_ until a continue is issued by the host.
   void Signal(uint32_t id, int8_t sig, bool wait);
 
   // This function will spin on a session, until it closes.  If an
   // exception is caught, it will signal the exception thread by
   // setting sig_done_.
   void Run(Session *ses);
 
   // This function causes the target to track the state
   // of the specified thread and make it availible to
   // a connected host.
   void TrackThread(port::IThread *thread);
 
   // This function causes the target to stop tracking the
   // state of the specified thread, which will no longer
   // be visible to the host.
   void IgnoreThread(port::IThread *thread);
 
  protected:
+  // Protected member functions, should only be called by the stub thread
+  // from within "Run", at which point stateMutex_ is already held, so
+  // it is always safe for a protected function to access the signal
+  // state or thread map.
+
+  // Called whenever the target transitions from running to stopped to
+  // update information about the current state.
+  void Update();
+
+  // Called to stop and start all debug threads
+  void Pause();
+  void Resume();
+
   // This function always succeedes, since all errors
   // are reported as an error string of "E<##>" where
   // the two digit number.  The error codes are not
   // not documented, so this implementation uses
   // ErrDef as errors codes.  This function returns
   // true a request to continue (or step) is processed.
   bool ProcessPacket(Packet *pktIn, Packet *pktOut);
 
   void Destroy();
   void Detach();
 
   bool GetFirstThreadId(uint32_t *id);
   bool GetNextThreadId(uint32_t *id);
 
-  uint32_t GetRegThreadId() const;
-  uint32_t GetRunThreadId() const;
-  port::IThread *GetThread(uint32_t id);
+  // If requested_thread_id differs from current_thread_id, updates
+  // current_thread_id to the thread that the debugger wants to operate on.
+  // Can be called with either the run_thread_ids or the register_thread_ids
+  // to influence control flow, or to access register values.
+  // Returns the value of current_thread_id.
+  int32_t UpdateThreadId(int32_t requested_thread_id,
+                         int32_t *current_thread_id);
+  port::IThread *GetThread(uint32_t id) const;
 
- public:
+ private:
+
+  // This constant denotes an unintialized thread id.
+  static const int32_t kUninitializedThreadId;
+  // This constant denotes the maximum length of a thread-id query response.
+  static const int32_t kMaxQCResponseLength;
+
   const Abi *abi_;
 
-  // This mutex protects debugging state (threads_, cur_signal, sig_thread_)
-  port::IMutex *mutex_;
+  // This mutex protects debugging state (threads_, cur_signal,
+  // signalling_thread_).  This mutex is held by the stub thread, while in a
+  // broken state.
+  port::IMutex *stateMutex_;
+
+  // This mutex protects the public data (breakpoint, property), and is only
+  // held temporarily as needed.
+  port::IMutex *publicMutex_;
 
   // This event is signalled when the target is really to process an
   // exception.  It ensures only one exception is processed at a time.
   port::IEvent *sig_start_;
 
   // This event is signalled when the target done processing an exception.
   port::IEvent *sig_done_;
 
-  // This value is set if the exception cather is requesting a continue signal
-  bool send_done_;
-
   ThreadMap_t threads_;
   ThreadMap_t::const_iterator threadItr_;
   BreakMap_t breakMap_;
 
-
+  // A map of generic properties for the target.
   PropertyMap_t properties_;
 
-  uint8_t *ctx_;         // Context Scratchpad
+  // Context Scratchpad
+  uint8_t *ctx_;
 
-  // The current signal and signaling thread data is protected by
+  // The current signal and signalling thread data is protected by
   // the mutex, and can only be owned by one thread at a time.
   // These values should only be written via the "Signal" member,
   // which will ensure that a new signal does not overwrite a
   // previous signal.
   volatile int8_t cur_signal_;
-  volatile uint32_t sig_thread_;
+  volatile uint32_t signalling_thread_;
 
-  uint32_t run_thread_;   // Which thread to issue step commands on
-  uint32_t reg_thread_;   // Which thread to issue context (reg) commands on
+  // The debugger tracks two thread ids for its operations, one for getting
+  // and setting registers, the other for step and continue.
+  // Though they are generally expected to be the same, this is a strict
+  // implementation of the RSP spec.
+
+  // The thread ID the debugger wants subsequent running related operations
+  // to act on.
+  int32_t requested_run_thread_id_;
+  // The thread ID the debugger wants subsequent register related operations
+  // act on.
+  int32_t requested_register_thread_id_;
+  // The thread ID that the debugger's stepping running operations currently
+  // act on.
+  int32_t current_run_thread_id_;
+  // The thread ID that the debugger's register related operations currently
+  // act on.
+  int32_t current_register_thread_id_;
 };
-
-
 }  // namespace gdb_rsp
 
 #endif  // NATIVE_CLIENT_GDB_RSP_TARGET_H_