[deliverable/binutils-gdb.git] / gdb / continuations.c

/* Continuations for GDB, the GNU debugger.

   Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
   1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
   2009, 2010, 2011 Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"
#include "gdbthread.h"
#include "inferior.h"

struct continuation
{
  struct continuation *next;
  void (*function) (void *);
  void (*free_arg) (void *);
  void *arg;
};

typedef void (make_continuation_ftype) (void *);

/* Add a new continuation to the continuation chain, and return the
   previous chain pointer to be passed later to do_continuations or
   discard_continuations.  Args are FUNCTION to run the continuation
   up with, and ARG to pass to it.  */

static struct continuation *
make_continuation (struct continuation **pmy_chain,
		   make_continuation_ftype *function,
		   void *arg,  void (*free_arg) (void *))
{
  struct continuation *new = XNEW (struct continuation);
  struct continuation *old_chain = *pmy_chain;

  new->next = *pmy_chain;
  new->function = function;
  new->free_arg = free_arg;
  new->arg = arg;
  *pmy_chain = new;

  return old_chain;
}

static void
do_my_continuations (struct continuation **pmy_chain,
		     struct continuation *old_chain)
{
  struct continuation *ptr;

  while ((ptr = *pmy_chain) != old_chain)
    {
      *pmy_chain = ptr->next;	/* Do this first in case of recursion.  */
      (*ptr->function) (ptr->arg);
      if (ptr->free_arg)
	(*ptr->free_arg) (ptr->arg);
      xfree (ptr);
    }
}

void
discard_my_continuations (struct continuation **pmy_chain,
			  struct continuation *old_chain)
{
  struct continuation *ptr;

  while ((ptr = *pmy_chain) != old_chain)
    {
      *pmy_chain = ptr->next;
      if (ptr->free_arg)
	(*ptr->free_arg) (ptr->arg);
      xfree (ptr);
    }
}

/* Add a continuation to the continuation list of THREAD.  The new
   continuation will be added at the front.  */

void
add_continuation (struct thread_info *thread,
		  void (*continuation_hook) (void *), void *args,
		  void (*continuation_free_args) (void *))
{
  struct continuation *continuations = thread->continuations;
  make_cleanup_ftype *continuation_hook_fn = continuation_hook;

  make_continuation (&continuations,
		     continuation_hook_fn,
		     args,
		     continuation_free_args);

  thread->continuations = continuations;
}

/* Add a continuation to the continuation list of INFERIOR.  The new
   continuation will be added at the front.  */

void
add_inferior_continuation (void (*continuation_hook) (void *), void *args,
			   void (*continuation_free_args) (void *))
{
  struct inferior *inf = current_inferior ();
  struct continuation *continuations = inf->continuations;
  make_cleanup_ftype *continuation_hook_fn = continuation_hook;

  make_continuation (&continuations,
		     continuation_hook_fn,
		     args,
		     continuation_free_args);

  inf->continuations = continuations;
}

/* Do all continuations of the current inferior.  */

void
do_all_inferior_continuations (void)
{
  struct continuation *continuations;
  struct inferior *inf = current_inferior ();

  if (inf->continuations == NULL)
    return;

  /* Copy the list header into another pointer, and set the global
     list header to null, so that the global list can change as a side
     effect of invoking the continuations and the processing of the
     preexisting continuations will not be affected.  */

  continuations = inf->continuations;
  inf->continuations = NULL;

  /* Work now on the list we have set aside.  */
  do_my_continuations (&continuations, NULL);
}

/* Get rid of all the inferior-wide continuations of INF.  */

void
discard_all_inferior_continuations (struct inferior *inf)
{
  struct continuation *continuation_ptr = inf->continuations;

  discard_my_continuations (&continuation_ptr, NULL);
  inf->continuations = NULL;
}

static void
restore_thread_cleanup (void *arg)
{
  ptid_t *ptid_p = arg;

  switch_to_thread (*ptid_p);
}

/* Walk down the continuation list of PTID, and execute all the
   continuations.  There is a problem though.  In some cases new
   continuations may be added while we are in the middle of this loop.
   If this happens they will be added in the front, and done before we
   have a chance of exhausting those that were already there.  We need
   to then save the beginning of the list in a pointer and do the
   continuations from there on, instead of using the global beginning
   of list as our iteration pointer.  */

static void
do_all_continuations_ptid (ptid_t ptid,
			   struct continuation **continuations_p)
{
  struct cleanup *old_chain;
  struct continuation *continuations;
  ptid_t current_thread;

  if (*continuations_p == NULL)
    return;

  current_thread = inferior_ptid;

  /* Restore selected thread on exit.  Don't try to restore the frame
     as well, because:

     - When running continuations, the selected frame is always #0.

     - The continuations may trigger symbol file loads, which may
     change the frame layout (frame ids change), which would trigger
     a warning if we used make_cleanup_restore_current_thread.  */

  old_chain = make_cleanup (restore_thread_cleanup, &current_thread);

  /* Let the continuation see this thread as selected.  */
  switch_to_thread (ptid);

  /* Copy the list header into another pointer, and set the global
     list header to null, so that the global list can change as a side
     effect of invoking the continuations and the processing of the
     preexisting continuations will not be affected.  */

  continuations = *continuations_p;
  *continuations_p = NULL;

  /* Work now on the list we have set aside.  */
  do_my_continuations (&continuations, NULL);

  do_cleanups (old_chain);
}

/* Callback for iterate over threads.  */

static int
do_all_continuations_thread_callback (struct thread_info *thread, void *data)
{
  do_all_continuations_ptid (thread->ptid, &thread->continuations);
  return 0;
}

/* Do all continuations of thread THREAD.  */

void
do_all_continuations_thread (struct thread_info *thread)
{
  do_all_continuations_thread_callback (thread, NULL);
}

/* Do all continuations of all threads.  */

void
do_all_continuations (void)
{
  iterate_over_threads (do_all_continuations_thread_callback, NULL);
}

/* Callback for iterate over threads.  */

static int
discard_all_continuations_thread_callback (struct thread_info *thread,
					   void *data)
{
  struct continuation *continuation_ptr = thread->continuations;

  discard_my_continuations (&continuation_ptr, NULL);
  thread->continuations = NULL;
  return 0;
}

/* Get rid of all the continuations of THREAD.  */

void
discard_all_continuations_thread (struct thread_info *thread)
{
  discard_all_continuations_thread_callback (thread, NULL);
}

/* Get rid of all the continuations of all threads.  */

void
discard_all_continuations (void)
{
  iterate_over_threads (discard_all_continuations_thread_callback, NULL);
}


/* Add a continuation to the intermediate continuation list of THREAD.
   The new continuation will be added at the front.  */

void
add_intermediate_continuation (struct thread_info *thread,
			       void (*continuation_hook)
			       (void *), void *args,
			       void (*continuation_free_args) (void *))
{
  struct continuation *continuations = thread->intermediate_continuations;
  make_cleanup_ftype *continuation_hook_fn = continuation_hook;

  make_continuation (&continuations,
		     continuation_hook_fn,
		     args,
		     continuation_free_args);

  thread->intermediate_continuations = continuations;
}

/* Walk down the cmd_continuation list, and execute all the
   continuations.  There is a problem though.  In some cases new
   continuations may be added while we are in the middle of this
   loop.  If this happens they will be added in the front, and done
   before we have a chance of exhausting those that were already
   there.  We need to then save the beginning of the list in a pointer
   and do the continuations from there on, instead of using the
   global beginning of list as our iteration pointer.  */

static int
do_all_intermediate_continuations_thread_callback (struct thread_info *thread,
						   void *data)
{
  do_all_continuations_ptid (thread->ptid,
			     &thread->intermediate_continuations);
  return 0;
}

/* Do all intermediate continuations of thread THREAD.  */

void
do_all_intermediate_continuations_thread (struct thread_info *thread)
{
  do_all_intermediate_continuations_thread_callback (thread, NULL);
}

/* Do all intermediate continuations of all threads.  */

void
do_all_intermediate_continuations (void)
{
  iterate_over_threads (do_all_intermediate_continuations_thread_callback,
			NULL);
}

/* Callback for iterate over threads.  */

static int
discard_all_intermediate_continuations_thread_callback (struct thread_info *thread,
							void *data)
{
  struct continuation *continuation_ptr = thread->intermediate_continuations;

  discard_my_continuations (&continuation_ptr, NULL);
  thread->intermediate_continuations = NULL;
  return 0;
}

/* Get rid of all the intermediate continuations of THREAD.  */

void
discard_all_intermediate_continuations_thread (struct thread_info *thread)
{
  discard_all_intermediate_continuations_thread_callback (thread, NULL);
}

/* Get rid of all the intermediate continuations of all threads.  */

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