+2017-12-06 Pedro Alves <palves@redhat.com>
+
+ * break-catch-syscall.c (insert_catch_syscall)
+ (remove_catch_syscall): Adjust to pass reference to
+ inf_data->syscalls_counts directly via gdb::array_view.
+ * fbsd-nat.c (fbsd_set_syscall_catchpoint): Adjust to use bool
+ and gdb::array_view.
+ * linux-nat.c (linux_child_set_syscall_catchpoint): Likewise.
+ * remote.c (remote_set_syscall_catchpoint): Likewise.
+ * target-debug.h (target_debug_print_bool): New.
+ (define target_debug_print_gdb_array_view_const_int): New.
+ * target-delegates.c: Regenerate.
+ * target.h (target_ops) <to_set_syscall_catchpoint>: Use
+ gdb::array_view and bool.
+ (target_set_syscall_catchpoint): Likewise.
+
2017-12-06 Simon Marchi <simon.marchi@ericsson.com>
* break-catch-syscall.c (catch_syscall_completer): Get pointers
return target_set_syscall_catchpoint (ptid_get_pid (inferior_ptid),
inf_data->total_syscalls_count != 0,
inf_data->any_syscall_count,
- inf_data->syscalls_counts.size (),
- inf_data->syscalls_counts.data ());
+ inf_data->syscalls_counts);
}
/* Implement the "remove" breakpoint_ops method for syscall
return target_set_syscall_catchpoint (ptid_get_pid (inferior_ptid),
inf_data->total_syscalls_count != 0,
inf_data->any_syscall_count,
- inf_data->syscalls_counts.size (),
- inf_data->syscalls_counts.data ());
+ inf_data->syscalls_counts);
}
/* Implement the "breakpoint_hit" breakpoint_ops method for syscall
#ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
static int
-fbsd_set_syscall_catchpoint (struct target_ops *self, int pid, int needed,
- int any_count, int table_size, int *table)
+fbsd_set_syscall_catchpoint (struct target_ops *self, int pid, bool needed,
+ int any_count,
+ gdb::array_view<const int> syscall_counts)
{
/* Ignore the arguments. inf-ptrace.c will use PT_SYSCALL which
static int
linux_child_set_syscall_catchpoint (struct target_ops *self,
- int pid, int needed, int any_count,
- int table_size, int *table)
+ int pid, bool needed, int any_count,
+ gdb::array_view<const int> syscall_counts)
{
if (!linux_supports_tracesysgood ())
return 1;
/* On GNU/Linux, we ignore the arguments. It means that we only
enable the syscall catchpoints, but do not disable them.
- Also, we do not use the `table' information because we do not
+ Also, we do not use the `syscall_counts' information because we do not
filter system calls here. We let GDB do the logic for us. */
return 0;
}
static int
remote_set_syscall_catchpoint (struct target_ops *self,
- int pid, int needed, int any_count,
- int table_size, int *table)
+ int pid, bool needed, int any_count,
+ gdb::array_view<const int> syscall_counts)
{
const char *catch_packet;
enum packet_result result;
return 1;
}
- if (needed && !any_count)
+ if (needed && any_count == 0)
{
- int i;
-
- /* Count how many syscalls are to be caught (table[sysno] != 0). */
- for (i = 0; i < table_size; i++)
+ /* Count how many syscalls are to be caught. */
+ for (size_t i = 0; i < syscall_counts.size (); i++)
{
- if (table[i] != 0)
+ if (syscall_counts[i] != 0)
n_sysno++;
}
}
const int maxpktsz = strlen ("QCatchSyscalls:1") + n_sysno * 9 + 1;
built_packet.reserve (maxpktsz);
built_packet = "QCatchSyscalls:1";
- if (!any_count)
+ if (any_count == 0)
{
- /* Add in catch_packet each syscall to be caught (table[i] != 0). */
- for (int i = 0; i < table_size; i++)
+ /* Add in each syscall to be caught. */
+ for (size_t i = 0; i < syscall_counts.size (); i++)
{
- if (table[i] != 0)
- string_appendf (built_packet, ";%x", i);
+ if (syscall_counts[i] != 0)
+ string_appendf (built_packet, ";%zx", i);
}
}
if (built_packet.size () > get_remote_packet_size ())
target_debug_do_print (((X) ? (X) : "(null)"))
#define target_debug_print_int(X) \
target_debug_do_print (plongest (X))
+#define target_debug_print_bool(X) \
+ target_debug_do_print ((X) ? "true" : "false")
#define target_debug_print_long(X) \
target_debug_do_print (plongest (X))
#define target_debug_print_enum_target_xfer_status(X) \
target_debug_do_print (plongest (X))
#define target_debug_print_traceframe_info_up(X) \
target_debug_do_print (host_address_to_string (X.get ()))
+#define target_debug_print_gdb_array_view_const_int(X) \
+ target_debug_do_print (host_address_to_string (X.data ()))
static void
target_debug_print_struct_target_waitstatus_p (struct target_waitstatus *status)
}
static int
-delegate_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5)
+delegate_set_syscall_catchpoint (struct target_ops *self, int arg1, bool arg2, int arg3, gdb::array_view<const int> arg4)
{
self = self->beneath;
- return self->to_set_syscall_catchpoint (self, arg1, arg2, arg3, arg4, arg5);
+ return self->to_set_syscall_catchpoint (self, arg1, arg2, arg3, arg4);
}
static int
-tdefault_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5)
+tdefault_set_syscall_catchpoint (struct target_ops *self, int arg1, bool arg2, int arg3, gdb::array_view<const int> arg4)
{
return 1;
}
static int
-debug_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5)
+debug_set_syscall_catchpoint (struct target_ops *self, int arg1, bool arg2, int arg3, gdb::array_view<const int> arg4)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_syscall_catchpoint (...)\n", debug_target.to_shortname);
- result = debug_target.to_set_syscall_catchpoint (&debug_target, arg1, arg2, arg3, arg4, arg5);
+ result = debug_target.to_set_syscall_catchpoint (&debug_target, arg1, arg2, arg3, arg4);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_syscall_catchpoint (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg1);
fputs_unfiltered (", ", gdb_stdlog);
- target_debug_print_int (arg2);
+ target_debug_print_bool (arg2);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg3);
fputs_unfiltered (", ", gdb_stdlog);
- target_debug_print_int (arg4);
- fputs_unfiltered (", ", gdb_stdlog);
- target_debug_print_int_p (arg5);
+ target_debug_print_gdb_array_view_const_int (arg4);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
void (*to_follow_exec) (struct target_ops *, struct inferior *, char *)
TARGET_DEFAULT_IGNORE ();
int (*to_set_syscall_catchpoint) (struct target_ops *,
- int, int, int, int, int *)
+ int, bool, int,
+ gdb::array_view<const int>)
TARGET_DEFAULT_RETURN (1);
int (*to_has_exited) (struct target_ops *, int, int, int *)
TARGET_DEFAULT_RETURN (0);
/* Syscall catch.
- NEEDED is nonzero if any syscall catch (of any kind) is requested.
- If NEEDED is zero, it means the target can disable the mechanism to
+ NEEDED is true if any syscall catch (of any kind) is requested.
+ If NEEDED is false, it means the target can disable the mechanism to
catch system calls because there are no more catchpoints of this type.
ANY_COUNT is nonzero if a generic (filter-less) syscall catch is
- being requested. In this case, both TABLE_SIZE and TABLE should
- be ignored.
+ being requested. In this case, SYSCALL_COUNTS should be ignored.
- TABLE_SIZE is the number of elements in TABLE. It only matters if
- ANY_COUNT is zero.
-
- TABLE is an array of ints, indexed by syscall number. An element in
- this array is nonzero if that syscall should be caught. This argument
- only matters if ANY_COUNT is zero.
+ SYSCALL_COUNTS is an array of ints, indexed by syscall number. An
+ element in this array is nonzero if that syscall should be caught.
+ This argument only matters if ANY_COUNT is zero.
Return 0 for success, 1 if syscall catchpoints are not supported or -1
for failure. */
-#define target_set_syscall_catchpoint(pid, needed, any_count, table_size, table) \
+#define target_set_syscall_catchpoint(pid, needed, any_count, syscall_counts) \
(*current_target.to_set_syscall_catchpoint) (¤t_target, \
pid, needed, any_count, \
- table_size, table)
+ syscall_counts)
/* Returns TRUE if PID has exited. And, also sets EXIT_STATUS to the
exit code of PID, if any. */
projects / binutils-gdb.git / commitdiff