contrib/gdb-7/gdb/continuations.c

   1 /* Continuations for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986-2015 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "gdbthread.h"
  22 #include "inferior.h"
  23 #include "continuations.h"
  24
  25 struct continuation
  26 {
  27   struct continuation *next;
  28   continuation_ftype *function;
  29   continuation_free_arg_ftype *free_arg;
  30   void *arg;
  31 };
  32
  33 /* Add a new continuation to the continuation chain.  Args are
  34    FUNCTION to run the continuation up with, and ARG to pass to
  35    it.  */
  36
  37 static void
  38 make_continuation (struct continuation **pmy_chain,
  39                    continuation_ftype *function,
  40                    void *arg,  void (*free_arg) (void *))
  41 {
  42   struct continuation *newobj = XNEW (struct continuation);
  43
  44   newobj->next = *pmy_chain;
  45   newobj->function = function;
  46   newobj->free_arg = free_arg;
  47   newobj->arg = arg;
  48   *pmy_chain = newobj;
  49 }
  50
  51 static void
  52 do_my_continuations_1 (struct continuation **pmy_chain, int err)
  53 {
  54   struct continuation *ptr;
  55
  56   while ((ptr = *pmy_chain) != NULL)
  57     {
  58       *pmy_chain = ptr->next;   /* Do this first in case of recursion.  */
  59       (*ptr->function) (ptr->arg, err);
  60       if (ptr->free_arg)
  61         (*ptr->free_arg) (ptr->arg);
  62       xfree (ptr);
  63     }
  64 }
  65
  66 static void
  67 do_my_continuations (struct continuation **list, int err)
  68 {
  69   struct continuation *continuations;
  70
  71   if (*list == NULL)
  72     return;
  73
  74   /* Copy the list header into another pointer, and set the global
  75      list header to null, so that the global list can change as a side
  76      effect of invoking the continuations and the processing of the
  77      preexisting continuations will not be affected.  */
  78
  79   continuations = *list;
  80   *list = NULL;
  81
  82   /* Work now on the list we have set aside.  */
  83   do_my_continuations_1 (&continuations, err);
  84 }
  85
  86 static void
  87 discard_my_continuations_1 (struct continuation **pmy_chain)
  88 {
  89   struct continuation *ptr;
  90
  91   while ((ptr = *pmy_chain) != NULL)
  92     {
  93       *pmy_chain = ptr->next;
  94       if (ptr->free_arg)
  95         (*ptr->free_arg) (ptr->arg);
  96       xfree (ptr);
  97     }
  98 }
  99
 100 static void
 101 discard_my_continuations (struct continuation **list)
 102 {
 103   discard_my_continuations_1 (list);
 104   *list = NULL;
 105 }
 106
 107 /* Add a continuation to the continuation list of INFERIOR.  The new
 108    continuation will be added at the front.  */
 109
 110 void
 111 add_inferior_continuation (continuation_ftype *hook, void *args,
 112                            continuation_free_arg_ftype *free_arg)
 113 {
 114   struct inferior *inf = current_inferior ();
 115
 116   make_continuation (&inf->continuations, hook, args, free_arg);
 117 }
 118
 119 /* Do all continuations of the current inferior.  */
 120
 121 void
 122 do_all_inferior_continuations (int err)
 123 {
 124   struct inferior *inf = current_inferior ();
 125   do_my_continuations (&inf->continuations, err);
 126 }
 127
 128 /* Get rid of all the inferior-wide continuations of INF.  */
 129
 130 void
 131 discard_all_inferior_continuations (struct inferior *inf)
 132 {
 133   discard_my_continuations (&inf->continuations);
 134 }
 135
 136 /* Add a continuation to the continuation list of THREAD.  The new
 137    continuation will be added at the front.  */
 138
 139 void
 140 add_continuation (struct thread_info *thread,
 141                   continuation_ftype *hook, void *args,
 142                   continuation_free_arg_ftype *free_arg)
 143 {
 144   make_continuation (&thread->continuations, hook, args, free_arg);
 145 }
 146
 147 static void
 148 restore_thread_cleanup (void *arg)
 149 {
 150   ptid_t *ptid_p = arg;
 151
 152   switch_to_thread (*ptid_p);
 153 }
 154
 155 /* Walk down the continuation list of PTID, and execute all the
 156    continuations.  There is a problem though.  In some cases new
 157    continuations may be added while we are in the middle of this loop.
 158    If this happens they will be added in the front, and done before we
 159    have a chance of exhausting those that were already there.  We need
 160    to then save the beginning of the list in a pointer and do the
 161    continuations from there on, instead of using the global beginning
 162    of list as our iteration pointer.  */
 163
 164 static void
 165 do_all_continuations_ptid (ptid_t ptid,
 166                            struct continuation **continuations_p,
 167                            int err)
 168 {
 169   struct cleanup *old_chain;
 170   ptid_t current_thread;
 171
 172   if (*continuations_p == NULL)
 173     return;
 174
 175   current_thread = inferior_ptid;
 176
 177   /* Restore selected thread on exit.  Don't try to restore the frame
 178      as well, because:
 179
 180      - When running continuations, the selected frame is always #0.
 181
 182      - The continuations may trigger symbol file loads, which may
 183      change the frame layout (frame ids change), which would trigger
 184      a warning if we used make_cleanup_restore_current_thread.  */
 185
 186   old_chain = make_cleanup (restore_thread_cleanup, &current_thread);
 187
 188   /* Let the continuation see this thread as selected.  */
 189   switch_to_thread (ptid);
 190
 191   do_my_continuations (continuations_p, err);
 192
 193   do_cleanups (old_chain);
 194 }
 195
 196 /* Callback for iterate over threads.  */
 197
 198 static int
 199 do_all_continuations_thread_callback (struct thread_info *thread, void *data)
 200 {
 201   int err = * (int *) data;
 202   do_all_continuations_ptid (thread->ptid, &thread->continuations, err);
 203   return 0;
 204 }
 205
 206 /* Do all continuations of thread THREAD.  */
 207
 208 void
 209 do_all_continuations_thread (struct thread_info *thread, int err)
 210 {
 211   do_all_continuations_thread_callback (thread, &err);
 212 }
 213
 214 /* Do all continuations of all threads.  */
 215
 216 void
 217 do_all_continuations (int err)
 218 {
 219   iterate_over_threads (do_all_continuations_thread_callback, &err);
 220 }
 221
 222 /* Callback for iterate over threads.  */
 223
 224 static int
 225 discard_all_continuations_thread_callback (struct thread_info *thread,
 226                                            void *data)
 227 {
 228   discard_my_continuations (&thread->continuations);
 229   return 0;
 230 }
 231
 232 /* Get rid of all the continuations of THREAD.  */
 233
 234 void
 235 discard_all_continuations_thread (struct thread_info *thread)
 236 {
 237   discard_all_continuations_thread_callback (thread, NULL);
 238 }
 239
 240 /* Get rid of all the continuations of all threads.  */
 241
 242 void
 243 discard_all_continuations (void)
 244 {
 245   iterate_over_threads (discard_all_continuations_thread_callback, NULL);
 246 }
 247
 248
 249 /* Add a continuation to the intermediate continuation list of THREAD.
 250    The new continuation will be added at the front.  */
 251
 252 void
 253 add_intermediate_continuation (struct thread_info *thread,
 254                                continuation_ftype *hook,
 255                                void *args,
 256                                continuation_free_arg_ftype *free_arg)
 257 {
 258   make_continuation (&thread->intermediate_continuations, hook,
 259                      args, free_arg);
 260 }
 261
 262 /* Walk down the cmd_continuation list, and execute all the
 263    continuations.  There is a problem though.  In some cases new
 264    continuations may be added while we are in the middle of this
 265    loop.  If this happens they will be added in the front, and done
 266    before we have a chance of exhausting those that were already
 267    there.  We need to then save the beginning of the list in a pointer
 268    and do the continuations from there on, instead of using the
 269    global beginning of list as our iteration pointer.  */
 270
 271 static int
 272 do_all_intermediate_continuations_thread_callback (struct thread_info *thread,
 273                                                    void *data)
 274 {
 275   int err = * (int *) data;
 276
 277   do_all_continuations_ptid (thread->ptid,
 278                              &thread->intermediate_continuations, err);
 279   return 0;
 280 }
 281
 282 /* Do all intermediate continuations of thread THREAD.  */
 283
 284 void
 285 do_all_intermediate_continuations_thread (struct thread_info *thread, int err)
 286 {
 287   do_all_intermediate_continuations_thread_callback (thread, &err);
 288 }
 289
 290 /* Do all intermediate continuations of all threads.  */
 291
 292 void
 293 do_all_intermediate_continuations (int err)
 294 {
 295   iterate_over_threads (do_all_intermediate_continuations_thread_callback,
 296                         &err);
 297 }
 298
 299 /* Callback for iterate over threads.  */
 300
 301 static int
 302 discard_all_intermediate_continuations_thread_callback (struct thread_info *thread,
 303                                                         void *data)
 304 {
 305   discard_my_continuations (&thread->intermediate_continuations);
 306   return 0;
 307 }
 308
 309 /* Get rid of all the intermediate continuations of THREAD.  */
 310
 311 void
 312 discard_all_intermediate_continuations_thread (struct thread_info *thread)
 313 {
 314   discard_all_intermediate_continuations_thread_callback (thread, NULL);
 315 }
 316
 317 /* Get rid of all the intermediate continuations of all threads.  */
 318
 319 void
 320 discard_all_intermediate_continuations (void)
 321 {
 322   iterate_over_threads (discard_all_intermediate_continuations_thread_callback,
 323                         NULL);
 324 }