binutils-gdb/gdb/cleanups.c

298 lines
8.9 KiB
C

/* Cleanup routines for GDB, the GNU debugger.
Copyright (C) 1986-2014 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 "gdb_assert.h"
/* The cleanup list records things that have to be undone
if an error happens (descriptors to be closed, memory to be freed, etc.)
Each link in the chain records a function to call and an
argument to give it.
Use make_cleanup to add an element to the cleanup chain.
Use do_cleanups to do all cleanup actions back to a given
point in the chain. Use discard_cleanups to remove cleanups
from the chain back to a given point, not doing them.
If the argument is pointer to allocated memory, then you need
to additionally set the 'free_arg' member to a function that will
free that memory. This function will be called both when the cleanup
is executed and when it's discarded. */
struct cleanup
{
struct cleanup *next;
void (*function) (void *);
void (*free_arg) (void *);
void *arg;
};
/* Used to mark the end of a cleanup chain.
The value is chosen so that it:
- is non-NULL so that make_cleanup never returns NULL,
- causes a segv if dereferenced
[though this won't catch errors that a value of, say,
((struct cleanup *) -1) will]
- displays as something useful when printed in gdb.
This is const for a bit of extra robustness.
It is initialized to coax gcc into putting it into .rodata.
All fields are initialized to survive -Wextra. */
static const struct cleanup sentinel_cleanup = { 0, 0, 0, 0 };
/* Handy macro to use when referring to sentinel_cleanup. */
#define SENTINEL_CLEANUP ((struct cleanup *) &sentinel_cleanup)
/* Chain of cleanup actions established with make_cleanup,
to be executed if an error happens. */
static struct cleanup *cleanup_chain = SENTINEL_CLEANUP;
/* Chain of cleanup actions established with make_final_cleanup,
to be executed when gdb exits. */
static struct cleanup *final_cleanup_chain = SENTINEL_CLEANUP;
/* Main worker routine to create a cleanup.
PMY_CHAIN is a pointer to either cleanup_chain or final_cleanup_chain.
FUNCTION is the function to call to perform the cleanup.
ARG is passed to FUNCTION when called.
FREE_ARG, if non-NULL, is called after the cleanup is performed.
The result is a pointer to the previous chain pointer
to be passed later to do_cleanups or discard_cleanups. */
static struct cleanup *
make_my_cleanup2 (struct cleanup **pmy_chain, make_cleanup_ftype *function,
void *arg, void (*free_arg) (void *))
{
struct cleanup *new
= (struct cleanup *) xmalloc (sizeof (struct cleanup));
struct cleanup *old_chain = *pmy_chain;
new->next = *pmy_chain;
new->function = function;
new->free_arg = free_arg;
new->arg = arg;
*pmy_chain = new;
gdb_assert (old_chain != NULL);
return old_chain;
}
/* Worker routine to create a cleanup without a destructor.
PMY_CHAIN is a pointer to either cleanup_chain or final_cleanup_chain.
FUNCTION is the function to call to perform the cleanup.
ARG is passed to FUNCTION when called.
The result is a pointer to the previous chain pointer
to be passed later to do_cleanups or discard_cleanups. */
static struct cleanup *
make_my_cleanup (struct cleanup **pmy_chain, make_cleanup_ftype *function,
void *arg)
{
return make_my_cleanup2 (pmy_chain, function, arg, NULL);
}
/* Add a new cleanup to the cleanup_chain,
and return the previous chain pointer
to be passed later to do_cleanups or discard_cleanups.
Args are FUNCTION to clean up with, and ARG to pass to it. */
struct cleanup *
make_cleanup (make_cleanup_ftype *function, void *arg)
{
return make_my_cleanup (&cleanup_chain, function, arg);
}
/* Same as make_cleanup except also includes TDOR, a destructor to free ARG.
DTOR is invoked when the cleanup is performed or when it is discarded. */
struct cleanup *
make_cleanup_dtor (make_cleanup_ftype *function, void *arg,
void (*dtor) (void *))
{
return make_my_cleanup2 (&cleanup_chain,
function, arg, dtor);
}
/* Same as make_cleanup except the cleanup is added to final_cleanup_chain. */
struct cleanup *
make_final_cleanup (make_cleanup_ftype *function, void *arg)
{
return make_my_cleanup (&final_cleanup_chain, function, arg);
}
/* Worker routine to perform cleanups.
PMY_CHAIN is a pointer to either cleanup_chain or final_cleanup_chain.
OLD_CHAIN is the result of a "make" cleanup routine.
Cleanups are performed until we get back to the old end of the chain. */
static void
do_my_cleanups (struct cleanup **pmy_chain,
struct cleanup *old_chain)
{
struct cleanup *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);
}
}
/* Return a value that can be passed to do_cleanups, do_final_cleanups to
indicate perform all cleanups. */
struct cleanup *
all_cleanups (void)
{
return SENTINEL_CLEANUP;
}
/* Discard cleanups and do the actions they describe
until we get back to the point OLD_CHAIN in the cleanup_chain. */
void
do_cleanups (struct cleanup *old_chain)
{
do_my_cleanups (&cleanup_chain, old_chain);
}
/* Discard cleanups and do the actions they describe
until we get back to the point OLD_CHAIN in the final_cleanup_chain. */
void
do_final_cleanups (struct cleanup *old_chain)
{
do_my_cleanups (&final_cleanup_chain, old_chain);
}
/* Main worker routine to discard cleanups.
PMY_CHAIN is a pointer to either cleanup_chain or final_cleanup_chain.
OLD_CHAIN is the result of a "make" cleanup routine.
Cleanups are discarded until we get back to the old end of the chain. */
static void
discard_my_cleanups (struct cleanup **pmy_chain,
struct cleanup *old_chain)
{
struct cleanup *ptr;
while ((ptr = *pmy_chain) != old_chain)
{
*pmy_chain = ptr->next;
if (ptr->free_arg)
(*ptr->free_arg) (ptr->arg);
xfree (ptr);
}
}
/* Discard cleanups, not doing the actions they describe,
until we get back to the point OLD_CHAIN in the cleanup chain. */
void
discard_cleanups (struct cleanup *old_chain)
{
discard_my_cleanups (&cleanup_chain, old_chain);
}
/* Discard final cleanups, not doing the actions they describe,
until we get back to the point OLD_CHAIN in the final cleanup chain. */
void
discard_final_cleanups (struct cleanup *old_chain)
{
discard_my_cleanups (&final_cleanup_chain, old_chain);
}
/* Main worker routine to save cleanups.
PMY_CHAIN is a pointer to either cleanup_chain or final_cleanup_chain.
The chain is emptied and the result is a pointer to the old chain. */
static struct cleanup *
save_my_cleanups (struct cleanup **pmy_chain)
{
struct cleanup *old_chain = *pmy_chain;
*pmy_chain = SENTINEL_CLEANUP;
return old_chain;
}
/* Set the cleanup_chain to 0, and return the old cleanup_chain. */
struct cleanup *
save_cleanups (void)
{
return save_my_cleanups (&cleanup_chain);
}
/* Set the final_cleanup_chain to 0, and return the old
final_cleanup_chain. */
struct cleanup *
save_final_cleanups (void)
{
return save_my_cleanups (&final_cleanup_chain);
}
/* Main worker routine to save cleanups.
PMY_CHAIN is a pointer to either cleanup_chain or final_cleanup_chain.
The chain is restored from CHAIN. */
static void
restore_my_cleanups (struct cleanup **pmy_chain, struct cleanup *chain)
{
if (*pmy_chain != SENTINEL_CLEANUP)
internal_warning (__FILE__, __LINE__,
_("restore_my_cleanups has found a stale cleanup"));
*pmy_chain = chain;
}
/* Restore the cleanup chain from a previously saved chain. */
void
restore_cleanups (struct cleanup *chain)
{
restore_my_cleanups (&cleanup_chain, chain);
}
/* Restore the final cleanup chain from a previously saved chain. */
void
restore_final_cleanups (struct cleanup *chain)
{
restore_my_cleanups (&final_cleanup_chain, chain);
}
/* Provide a known function that does nothing, to use as a base for
a possibly long chain of cleanups. This is useful where we
use the cleanup chain for handling normal cleanups as well as dealing
with cleanups that need to be done as a result of a call to error().
In such cases, we may not be certain where the first cleanup is, unless
we have a do-nothing one to always use as the base. */
void
null_cleanup (void *arg)
{
}