/* Everything about syscall catchpoints, for GDB.
- Copyright (C) 2009-2017 Free Software Foundation, Inc.
+ Copyright (C) 2009-2018 Free Software Foundation, Inc.
This file is part of GDB.
#include "mi/mi-common.h"
#include "valprint.h"
#include "arch-utils.h"
-#include "observer.h"
+#include "observable.h"
#include "xml-syscall.h"
/* An instance of this type is used to represent a syscall catchpoint.
int any_syscall_count;
/* Count of each system call. */
- VEC(int) *syscalls_counts;
+ std::vector<int> syscalls_counts;
/* This counts all syscall catch requests, so we can readily determine
if any catching is necessary. */
int total_syscalls_count;
};
-static struct catch_syscall_inferior_data*
+static struct catch_syscall_inferior_data *
get_catch_syscall_inferior_data (struct inferior *inf)
{
struct catch_syscall_inferior_data *inf_data;
inferior_data (inf, catch_syscall_inferior_data));
if (inf_data == NULL)
{
- inf_data = XCNEW (struct catch_syscall_inferior_data);
+ inf_data = new struct catch_syscall_inferior_data ();
set_inferior_data (inf, catch_syscall_inferior_data, inf_data);
}
static void
catch_syscall_inferior_data_cleanup (struct inferior *inf, void *arg)
{
- xfree (arg);
+ struct catch_syscall_inferior_data *inf_data
+ = (struct catch_syscall_inferior_data *) arg;
+ delete inf_data;
}
{
for (int iter : c->syscalls_to_be_caught)
{
- int elem;
-
- if (iter >= VEC_length (int, inf_data->syscalls_counts))
- {
- int old_size = VEC_length (int, inf_data->syscalls_counts);
- uintptr_t vec_addr_offset
- = old_size * ((uintptr_t) sizeof (int));
- uintptr_t vec_addr;
- VEC_safe_grow (int, inf_data->syscalls_counts, iter + 1);
- vec_addr = ((uintptr_t) VEC_address (int,
- inf_data->syscalls_counts)
- + vec_addr_offset);
- memset ((void *) vec_addr, 0,
- (iter + 1 - old_size) * sizeof (int));
- }
- elem = VEC_index (int, inf_data->syscalls_counts, iter);
- VEC_replace (int, inf_data->syscalls_counts, iter, ++elem);
+ if (iter >= inf_data->syscalls_counts.size ())
+ inf_data->syscalls_counts.resize (iter + 1);
+ ++inf_data->syscalls_counts[iter];
}
}
return target_set_syscall_catchpoint (ptid_get_pid (inferior_ptid),
inf_data->total_syscalls_count != 0,
inf_data->any_syscall_count,
- VEC_length (int,
- inf_data->syscalls_counts),
- VEC_address (int,
- inf_data->syscalls_counts));
+ inf_data->syscalls_counts);
}
/* Implement the "remove" breakpoint_ops method for syscall
{
for (int iter : c->syscalls_to_be_caught)
{
- int elem;
- if (iter >= VEC_length (int, inf_data->syscalls_counts))
+ if (iter >= inf_data->syscalls_counts.size ())
/* Shouldn't happen. */
continue;
- elem = VEC_index (int, inf_data->syscalls_counts, iter);
- VEC_replace (int, inf_data->syscalls_counts, iter, --elem);
+ --inf_data->syscalls_counts[iter];
}
}
return target_set_syscall_catchpoint (ptid_get_pid (inferior_ptid),
inf_data->total_syscalls_count != 0,
inf_data->any_syscall_count,
- VEC_length (int,
- inf_data->syscalls_counts),
- VEC_address (int,
- inf_data->syscalls_counts));
+ inf_data->syscalls_counts);
}
/* Implement the "breakpoint_hit" breakpoint_ops method for syscall
static int
breakpoint_hit_catch_syscall (const struct bp_location *bl,
- struct address_space *aspace, CORE_ADDR bp_addr,
+ const address_space *aspace, CORE_ADDR bp_addr,
const struct target_waitstatus *ws)
{
/* We must check if we are catching specific syscalls in this
create_syscall_event_catchpoint (int tempflag, std::vector<int> &&filter,
const struct breakpoint_ops *ops)
{
- struct syscall_catchpoint *c;
struct gdbarch *gdbarch = get_current_arch ();
- c = new syscall_catchpoint ();
- init_catchpoint (c, gdbarch, tempflag, NULL, ops);
- c->syscalls_to_be_caught = filter;
+ std::unique_ptr<syscall_catchpoint> c (new syscall_catchpoint ());
+ init_catchpoint (c.get (), gdbarch, tempflag, NULL, ops);
+ c->syscalls_to_be_caught = std::move (filter);
- install_breakpoint (0, c, 1);
+ install_breakpoint (0, std::move (c), 1);
}
/* Splits the argument using space as delimiter. */
static std::vector<int>
-catch_syscall_split_args (char *arg)
+catch_syscall_split_args (const char *arg)
{
std::vector<int> result;
struct gdbarch *gdbarch = target_gdbarch ();
/* Implement the "catch syscall" command. */
static void
-catch_syscall_command_1 (char *arg, int from_tty,
+catch_syscall_command_1 (const char *arg, int from_tty,
struct cmd_list_element *command)
{
int tempflag;
const char *text, const char *word)
{
struct gdbarch *gdbarch = get_current_arch ();
- struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
- const char **group_list = NULL;
- const char **syscall_list = NULL;
+ gdb::unique_xmalloc_ptr<const char *> group_list;
const char *prefix;
- int i;
/* Completion considers ':' to be a word separator, so we use this to
verify whether the previous word was a group prefix. If so, we
if (startswith (prefix, "g:") || startswith (prefix, "group:"))
{
/* Perform completion inside 'group:' namespace only. */
- group_list = get_syscall_group_names (gdbarch);
+ group_list.reset (get_syscall_group_names (gdbarch));
if (group_list != NULL)
- complete_on_enum (tracker, group_list, word, word);
+ complete_on_enum (tracker, group_list.get (), word, word);
}
else
{
/* Complete with both, syscall names and groups. */
- syscall_list = get_syscall_names (gdbarch);
- group_list = get_syscall_group_names (gdbarch);
+ gdb::unique_xmalloc_ptr<const char *> syscall_list
+ (get_syscall_names (gdbarch));
+ group_list.reset (get_syscall_group_names (gdbarch));
+
+ const char **group_ptr = group_list.get ();
+
+ /* Hold on to strings while we're using them. */
+ std::vector<std::string> holders;
/* Append "group:" prefix to syscall groups. */
- for (i = 0; group_list[i] != NULL; i++)
- {
- char *prefixed_group = xstrprintf ("group:%s", group_list[i]);
+ for (int i = 0; group_ptr[i] != NULL; i++)
+ holders.push_back (string_printf ("group:%s", group_ptr[i]));
- group_list[i] = prefixed_group;
- make_cleanup (xfree, prefixed_group);
- }
+ for (int i = 0; group_ptr[i] != NULL; i++)
+ group_ptr[i] = holders[i].c_str ();
if (syscall_list != NULL)
- complete_on_enum (tracker, syscall_list, word, word);
+ complete_on_enum (tracker, syscall_list.get (), word, word);
if (group_list != NULL)
- complete_on_enum (tracker, group_list, word, word);
+ complete_on_enum (tracker, group_ptr, word, word);
}
-
- xfree (syscall_list);
- xfree (group_list);
- do_cleanups (cleanups);
}
static void
inf_data->total_syscalls_count = 0;
inf_data->any_syscall_count = 0;
- VEC_free (int, inf_data->syscalls_counts);
+ inf_data->syscalls_counts.clear ();
}
static void
ops->print_recreate = print_recreate_catch_syscall;
}
-initialize_file_ftype _initialize_break_catch_syscall;
-
void
_initialize_break_catch_syscall (void)
{
initialize_syscall_catchpoint_ops ();
- observer_attach_inferior_exit (clear_syscall_counts);
+ gdb::observers::inferior_exit.attach (clear_syscall_counts);
catch_syscall_inferior_data
= register_inferior_data_with_cleanup (NULL,
catch_syscall_inferior_data_cleanup);