binutils-gdb/gdbsupport/cleanups.cc
Joel Brobecker 4a94e36819 Automatic Copyright Year update after running gdb/copyright.py
This commit brings all the changes made by running gdb/copyright.py
as per GDB's Start of New Year Procedure.

For the avoidance of doubt, all changes in this commits were
performed by the script.
2022-01-01 19:13:23 +04:00

145 lines
4.9 KiB
C++

/* Cleanup routines for GDB, the GNU debugger.
Copyright (C) 1986-2022 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 "common-defs.h"
#include "cleanups.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_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 *newobj = XNEW (struct cleanup);
struct cleanup *old_chain = *pmy_chain;
newobj->next = *pmy_chain;
newobj->function = function;
newobj->free_arg = free_arg;
newobj->arg = arg;
*pmy_chain = newobj;
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 final 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_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);
}
}
/* Discard final cleanups and do the actions they describe. */
void
do_final_cleanups ()
{
do_my_cleanups (&final_cleanup_chain, SENTINEL_CLEANUP);
}