gdb/thread-fsm.h

   1 /* Thread command's finish-state machine, for GDB, the GNU debugger.
   2    Copyright (C) 2015-2016 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 #ifndef THREAD_FSM_H
  20 #define THREAD_FSM_H
  21
  22 #include "mi/mi-common.h" /* For enum async_reply_reason.  */
  23
  24 struct return_value_info;
  25 struct thread_fsm_ops;
  26
  27 /* A thread finite-state machine structure contains the necessary info
  28    and callbacks to manage the state machine protocol of a thread's
  29    execution command.  */
  30
  31 struct thread_fsm
  32 {
  33   /* Pointer of the virtual table of methods.  */
  34   struct thread_fsm_ops *ops;
  35
  36   /* Whether the FSM is done successfully.  */
  37   int finished;
  38 };
  39
  40 /* The virtual table of a thread_fsm.  */
  41
  42 struct thread_fsm_ops
  43 {
  44   /* The destructor.  This should simply free heap allocated data
  45      structures.  Cleaning up target resources (like, e.g.,
  46      breakpoints) should be done in the clean_up method.  */
  47   void (*dtor) (struct thread_fsm *self);
  48
  49   /* Called to clean up target resources after the FSM.  E.g., if the
  50      FSM created internal breakpoints, this is where they should be
  51      deleted.  */
  52   void (*clean_up) (struct thread_fsm *self);
  53
  54   /* Called after handle_inferior_event decides the target is done
  55      (that is, after stop_waiting).  The FSM is given a chance to
  56      decide whether the command is done and thus the target should
  57      stop, or whether there's still more to do and thus the thread
  58      should be re-resumed.  This is a good place to cache target data
  59      too.  For example, the "finish" command saves the just-finished
  60      function's return value here.  */
  61   int (*should_stop) (struct thread_fsm *self);
  62
  63   /* If this FSM saved a function's return value, you can use this
  64      method to retrieve it.  Otherwise, this returns NULL.  */
  65   struct return_value_info *(*return_value) (struct thread_fsm *self);
  66
  67   /* The async_reply_reason that is broadcast to MI clients if this
  68      FSM finishes successfully.  */
  69   enum async_reply_reason (*async_reply_reason) (struct thread_fsm *self);
  70
  71   /* Whether the stop should be notified to the user/frontend.  */
  72   int (*should_notify_stop) (struct thread_fsm *self);
  73 };
  74 /* Initialize FSM.  */
  75 extern void thread_fsm_ctor (struct thread_fsm *fsm,
  76                              struct thread_fsm_ops *ops);
  77
  78 /* Calls the FSM's dtor method, and then frees FSM.  */
  79 extern void thread_fsm_delete (struct thread_fsm *fsm);
  80
  81 /* Calls the FSM's clean_up method.  */
  82 extern void thread_fsm_clean_up (struct thread_fsm *fsm);
  83
  84 /* Calls the FSM's should_stop method.  */
  85 extern int thread_fsm_should_stop (struct thread_fsm *fsm);
  86
  87 /* Calls the FSM's return_value method.  */
  88 extern struct return_value_info *
  89   thread_fsm_return_value (struct thread_fsm *fsm);
  90
  91 /* Marks the FSM as completed successfully.  */
  92 extern void thread_fsm_set_finished (struct thread_fsm *fsm);
  93
  94 /* Returns true if the FSM completed successfully.  */
  95 extern int thread_fsm_finished_p (struct thread_fsm *fsm);
  96
  97 /* Calls the FSM's reply_reason method.  */
  98 extern enum async_reply_reason
  99   thread_fsm_async_reply_reason (struct thread_fsm *fsm);
 100
 101 /* Calls the FSM's should_notify_stop method.  */
 102 extern int thread_fsm_should_notify_stop (struct thread_fsm *self);
 103
 104 #endif /* THREAD_FSM_H */