@@ -11073,7 +11073,6 @@ until_break_command (const char *arg, int from_tty, int anywhere)
struct gdbarch *frame_gdbarch;
struct frame_id stack_frame_id;
struct frame_id caller_frame_id;
- struct cleanup *old_chain;
int thread;
struct thread_info *tp;
struct until_break_fsm *sm;
@@ -11106,8 +11105,6 @@ until_break_command (const char *arg, int from_tty, int anywhere)
tp = inferior_thread ();
thread = tp->global_num;
- old_chain = make_cleanup (null_cleanup, NULL);
-
/* Note linespec handling above invalidates the frame chain.
Installing a breakpoint also invalidates the frame chain (as it
may need to switch threads), so do any frame handling before
@@ -11122,6 +11119,9 @@ until_break_command (const char *arg, int from_tty, int anywhere)
one. */
breakpoint_up caller_breakpoint;
+
+ gdb::optional<longjmp_breakpoint_cleanup> lj_deleter;
+
if (frame_id_p (caller_frame_id))
{
struct symtab_and_line sal2;
@@ -11136,7 +11136,7 @@ until_break_command (const char *arg, int from_tty, int anywhere)
bp_until);
set_longjmp_breakpoint (tp, caller_frame_id);
- make_cleanup (delete_longjmp_breakpoint_cleanup, &thread);
+ lj_deleter.emplace (thread);
}
/* set_momentary_breakpoint could invalidate FRAME. */
@@ -11159,7 +11159,8 @@ until_break_command (const char *arg, int from_tty, int anywhere)
std::move (caller_breakpoint));
tp->thread_fsm = &sm->thread_fsm;
- discard_cleanups (old_chain);
+ if (lj_deleter)
+ lj_deleter->cancel ();
proceed (-1, GDB_SIGNAL_DEFAULT);
}
@@ -30,6 +30,7 @@
#include <vector>
#include "common/array-view.h"
#include "cli/cli-script.h"
+#include "common/cleanup-function.h"
struct block;
struct gdbpy_breakpoint_object;
@@ -1431,6 +1432,15 @@ extern void set_longjmp_breakpoint (struct thread_info *tp,
struct frame_id frame);
extern void delete_longjmp_breakpoint (int thread);
+/* Cleanup class that calls delete_longjmp_breakpoint. */
+#ifdef __cpp_template_auto
+using longjmp_breakpoint_cleanup
+ = cleanup_function <delete_longjmp_breakpoint, int>;
+#else
+using longjmp_breakpoint_cleanup
+= cleanup_function <void (*) (int), delete_longjmp_breakpoint, int>;
+#endif
+
/* Mark all longjmp breakpoints from THREAD for later deletion. */
extern void delete_longjmp_breakpoint_at_next_stop (int thread);
new file mode 100644
@@ -0,0 +1,118 @@
+/* Copyright (C) 2019 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/>. */
+
+#ifndef COMMON_CLEANUP_FUNCTION_H
+#define COMMON_CLEANUP_FUNCTION_H
+
+#include <tuple>
+
+/* This is the general part of a recursive template to unpack the arguments
+ from the tuple PARAMS into ARGS. The template parameter N is the number
+ of parameters left to unpack from PARAMS. Each iteration takes an extra
+ parameter from PARAMS and passes it as an extra argument to
+ CALL_FUNCTION_ON_TUPLE::UNPACK_TUPLE, reducing N until we hit the base
+ case below. */
+template <unsigned int N>
+struct call_function_on_tuple
+{
+ template <typename... FuncArgTypes, typename... UnpackedArgTypes>
+ static void unpack (void (*func) (FuncArgTypes... ),
+ const std::tuple<FuncArgTypes...>& params,
+ UnpackedArgTypes... args)
+ {
+ call_function_on_tuple<N-1>::unpack (func, params,
+ std::get<N-1> (params),
+ args...);
+ }
+};
+
+/* This is the base case specialisation, when we reach this point all of
+ the arguments have been extracted from PARAMS and are being passed in
+ ARGS. It is worth noting that ARGS must be non-empty, thus this can't
+ be used to call FUNC if FUNC takes no parameters. This special case is
+ handled within CLEANUP_FUNCTION::UNPACK_TUPLE below. */
+template <>
+struct call_function_on_tuple<0>
+{
+ template <typename... FuncArgTypes, typename... UnpackedArgTypes>
+ static void unpack (void (*func) (FuncArgTypes...),
+ const std::tuple<FuncArgTypes...>& params,
+ UnpackedArgTypes... args)
+ {
+ func (args...);
+ }
+};
+
+/* In a C++17 world we can make use of the `auto` keyword in the template
+ parameter list to avoid having to pass the function type signature as a
+ separate template parameter. */
+
+#ifdef __cpp_template_auto
+template <auto function, typename... Args>
+#else
+template <typename f_type, f_type function, typename... Args>
+#endif
+class cleanup_function
+{
+public:
+
+ explicit cleanup_function (Args... args)
+ : m_args (std::forward<Args>(args)...)
+ { /* Nothing. */ }
+
+ ~cleanup_function ()
+ {
+ /* Maybe we should be try/catch around this? */
+ if (!m_cancelled)
+ unpack_tuple_and_call (function, m_args);
+ }
+
+ /* Mark this cleanup as cancelled, the cleanup function will not be
+ called. */
+ void cancel ()
+ {
+ m_cancelled = true;
+ }
+
+private:
+
+ /* This is the entry point for calling function F with the contents of
+ tuple PARAMS as arguments in the case where the tuple actually holds
+ some values. */
+ template <typename... FuncArgTypes>
+ void unpack_tuple_and_call (void (*f) (FuncArgTypes...),
+ std::tuple<FuncArgTypes...> const& params)
+ {
+ call_function_on_tuple<sizeof...(FuncArgTypes)>::unpack (f, params);
+ }
+
+ /* This is the entry point for calling function F for the case where F
+ takes no parameters. */
+ template <typename = void>
+ void unpack_tuple_and_call (void (*f) (void), std::tuple<> const& params)
+ {
+ f ();
+ }
+
+ /* Storage for the arguments to the cleanup function */
+ std::tuple<Args...> m_args;
+
+ /* Has this cleanup been cancelled? */
+ bool m_cancelled = false;
+};
+
+#endif /* COMMON_CLEANUP_FUNCTION_H */
@@ -947,13 +947,6 @@ nexti_command (const char *count_string, int from_tty)
step_1 (1, 1, count_string);
}
-void
-delete_longjmp_breakpoint_cleanup (void *arg)
-{
- int thread = * (int *) arg;
- delete_longjmp_breakpoint (thread);
-}
-
/* Data for the FSM that manages the step/next/stepi/nexti
commands. */
@@ -1517,7 +1510,6 @@ until_next_command (int from_tty)
struct symtab_and_line sal;
struct thread_info *tp = inferior_thread ();
int thread = tp->global_num;
- struct cleanup *old_chain;
struct until_next_fsm *sm;
clear_proceed_status (0);
@@ -1556,11 +1548,11 @@ until_next_command (int from_tty)
tp->control.step_over_calls = STEP_OVER_ALL;
set_longjmp_breakpoint (tp, get_frame_id (frame));
- old_chain = make_cleanup (delete_longjmp_breakpoint_cleanup, &thread);
+ longjmp_breakpoint_cleanup lj_deleter (thread);
sm = new_until_next_fsm (command_interp (), tp->global_num);
tp->thread_fsm = &sm->thread_fsm;
- discard_cleanups (old_chain);
+ lj_deleter.cancel ();
proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
}
@@ -198,8 +198,6 @@ extern void continue_1 (int all_threads);
extern void interrupt_target_1 (int all_threads);
-extern void delete_longjmp_breakpoint_cleanup (void *arg);
-
extern void detach_command (const char *, int);
extern void notice_new_inferior (struct thread_info *, int, int);