From: Pedro Alves Date: Fri, 27 May 2011 14:00:25 +0000 (+0000) Subject: 2011-05-27 Pedro Alves X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=50c0c01734cfcab78db070b71f9f377c7e28d7e9;p=binutils-gdb.git 2011-05-27 Pedro Alves gdb/ * utils.c (struct continuation, add_continuation) (add_inferior_continuation) (do_all_inferior_continuations, discard_all_inferior_continuations) (restore_thread_cleanup, do_all_continuations_ptid) (do_all_continuations_thread_callback) (do_all_continuations_thread, do_all_continuations) (discard_all_continuations_thread_callback) (discard_all_continuations_thread, discard_all_continuations) (add_intermediate_continuation) (do_all_intermediate_continuations_thread_callback) (do_all_intermediate_continuations_thread) (do_all_intermediate_continuations) (discard_all_intermediate_continuations_thread_callback) (discard_all_intermediate_continuations_thread) (discard_all_intermediate_continuations): Move to ... * continuations.c: ... this new file, and adjust to no longer implement continuations on top of cleanups. * Makefile.in (SFILES): Add continuations.c. (COMMON_OBS): Add continuations.o. --- diff --git a/gdb/ChangeLog b/gdb/ChangeLog index e1113282fbc..3eded8008dc 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,25 @@ +2011-05-27 Pedro Alves + + * utils.c (struct continuation, add_continuation) + (add_inferior_continuation) + (do_all_inferior_continuations, discard_all_inferior_continuations) + (restore_thread_cleanup, do_all_continuations_ptid) + (do_all_continuations_thread_callback) + (do_all_continuations_thread, do_all_continuations) + (discard_all_continuations_thread_callback) + (discard_all_continuations_thread, discard_all_continuations) + (add_intermediate_continuation) + (do_all_intermediate_continuations_thread_callback) + (do_all_intermediate_continuations_thread) + (do_all_intermediate_continuations) + (discard_all_intermediate_continuations_thread_callback) + (discard_all_intermediate_continuations_thread) + (discard_all_intermediate_continuations): Move to ... + * continuations.c: ... this new file, and adjust to no longer + implement continuations on top of cleanups. + * Makefile.in (SFILES): Add continuations.c. + (COMMON_OBS): Add continuations.o. + 2011-05-26 Pedro Alves * inferior.h (enum exec_direction_kind): Delete EXEC_ERROR. diff --git a/gdb/Makefile.in b/gdb/Makefile.in index 5bab360132c..ebb91ef55b2 100644 --- a/gdb/Makefile.in +++ b/gdb/Makefile.in @@ -689,7 +689,7 @@ SFILES = ada-exp.y ada-lang.c ada-typeprint.c ada-valprint.c ada-tasks.c \ block.c blockframe.c breakpoint.c buildsym.c \ c-exp.y c-lang.c c-typeprint.c c-valprint.c \ charset.c cli-out.c coffread.c coff-pe-read.c \ - complaints.c completer.c corefile.c \ + complaints.c completer.c continuations.c corefile.c \ cp-abi.c cp-support.c cp-namespace.c cp-valprint.c \ d-lang.c d-valprint.c \ cp-name-parser.y \ @@ -849,7 +849,7 @@ COMMON_OBS = $(DEPFILES) $(CONFIG_OBS) $(YYOBJ) \ auxv.o \ bfd-target.o \ blockframe.o breakpoint.o findvar.o regcache.o \ - charset.o disasm.o dummy-frame.o dfp.o \ + charset.o continuations.o disasm.o dummy-frame.o dfp.o \ source.o value.o eval.o valops.o valarith.o valprint.o printcmd.o \ block.o symtab.o psymtab.o symfile.o symmisc.o linespec.o dictionary.o \ infcall.o \ diff --git a/gdb/continuations.c b/gdb/continuations.c new file mode 100644 index 00000000000..1d62a12847a --- /dev/null +++ b/gdb/continuations.c @@ -0,0 +1,357 @@ +/* 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 . */ + +#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, ¤t_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); +} diff --git a/gdb/utils.c b/gdb/utils.c index 6fd220a6059..d10669a72c9 100644 --- a/gdb/utils.c +++ b/gdb/utils.c @@ -718,268 +718,6 @@ make_command_stats_cleanup (int msg_type) return make_cleanup_dtor (report_command_stats, new_stat, xfree); } - -/* Continuations are implemented as cleanups internally. Inherit from - cleanups. */ -struct continuation -{ - struct cleanup base; -}; - -/* 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 cleanup *as_cleanup = &thread->continuations->base; - make_cleanup_ftype *continuation_hook_fn = continuation_hook; - - make_my_cleanup2 (&as_cleanup, - continuation_hook_fn, - args, - continuation_free_args); - - thread->continuations = (struct continuation *) as_cleanup; -} - -/* 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 cleanup *as_cleanup = &inf->continuations->base; - make_cleanup_ftype *continuation_hook_fn = continuation_hook; - - make_my_cleanup2 (&as_cleanup, - continuation_hook_fn, - args, - continuation_free_args); - - inf->continuations = (struct continuation *) as_cleanup; -} - -/* Do all continuations of the current inferior. */ - -void -do_all_inferior_continuations (void) -{ - struct cleanup *as_cleanup; - 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. */ - - as_cleanup = &inf->continuations->base; - inf->continuations = NULL; - - /* Work now on the list we have set aside. */ - do_my_cleanups (&as_cleanup, NULL); -} - -/* Get rid of all the inferior-wide continuations of INF. */ - -void -discard_all_inferior_continuations (struct inferior *inf) -{ - struct cleanup *continuation_ptr = &inf->continuations->base; - - discard_my_cleanups (&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; - ptid_t current_thread; - struct cleanup *as_cleanup; - - 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, ¤t_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. */ - - as_cleanup = &(*continuations_p)->base; - *continuations_p = NULL; - - /* Work now on the list we have set aside. */ - do_my_cleanups (&as_cleanup, 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 cleanup *continuation_ptr = &thread->continuations->base; - - discard_my_cleanups (&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 cleanup *as_cleanup = &thread->intermediate_continuations->base; - make_cleanup_ftype *continuation_hook_fn = continuation_hook; - - make_my_cleanup2 (&as_cleanup, - continuation_hook_fn, - args, - continuation_free_args); - - thread->intermediate_continuations = (struct continuation *) as_cleanup; -} - -/* 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 cleanup *continuation_ptr = &thread->intermediate_continuations->base; - - discard_my_cleanups (&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); -}