+2020-09-28 Tom Tromey <tom@tromey.com>
+
+ * inferior.h (class inferior) <has_execution>: Update.
+ * windows-tdep.c (windows_solib_create_inferior_hook): Update.
+ * valops.c (find_function_in_inferior)
+ (value_allocate_space_in_inferior): Update.
+ * top.c (kill_or_detach): Update.
+ * target.c (target_preopen, set_target_permissions): Update.
+ (target_has_execution_current): Remove.
+ * sparc64-tdep.c (adi_examine_command, adi_assign_command):
+ Update.
+ * solib.c (update_solib_list, reload_shared_libraries): Update.
+ * solib-svr4.c (svr4_solib_create_inferior_hook): Update.
+ * solib-dsbt.c (enable_break): Update.
+ * score-tdep.c (score7_fetch_inst): Update.
+ * rs6000-nat.c (rs6000_nat_target::xfer_shared_libraries):
+ Update.
+ * remote.c (remote_target::start_remote)
+ (remote_target::remote_check_symbols, remote_target::open_1)
+ (remote_target::remote_detach_1, remote_target::verify_memory)
+ (remote_target::xfer_partial, remote_target::read_description)
+ (remote_target::get_min_fast_tracepoint_insn_len): Update.
+ * record-full.c (record_full_open_1): Update.
+ * record-btrace.c (record_btrace_target_open): Update.
+ * objc-lang.c (lookup_objc_class, lookup_child_selector)
+ (value_nsstring): Update.
+ * linux-thread-db.c (add_thread_db_info)
+ (thread_db_find_new_threads_silently, check_thread_db_callback)
+ (try_thread_db_load_1, record_thread): Update.
+ * linux-tdep.c (linux_info_proc, linux_vsyscall_range_raw):
+ Update.
+ * linux-fork.c (checkpoint_command): Update.
+ * infrun.c (set_non_stop, set_observer_mode)
+ (check_multi_target_resumption, for_each_just_stopped_thread)
+ (maybe_remove_breakpoints, normal_stop)
+ (class infcall_suspend_state): Update.
+ * infcmd.c (ERROR_NO_INFERIOR, kill_if_already_running)
+ (info_program_command, attach_command): Update.
+ * infcall.c (call_function_by_hand_dummy): Update.
+ * inf-loop.c (inferior_event_handler): Update.
+ * gcore.c (gcore_command, derive_heap_segment): Update.
+ * exec.c (exec_file_command): Update.
+ * eval.c (evaluate_subexp): Update.
+ * compile/compile.c (compile_to_object): Update.
+ * cli/cli-dump.c (restore_command): Update.
+ * breakpoint.c (update_watchpoint)
+ (update_inserted_breakpoint_locations)
+ (insert_breakpoint_locations, get_bpstat_thread): Update.
+ * target.h (target_has_execution): Remove macro.
+ (target_has_execution_current): Don't declare.
+ (target_has_execution): Rename from target_has_execution_1. Add
+ argument default.
+
2020-09-28 Tom Tromey <tom@tromey.com>
* mi/mi-main.c (exec_reverse_continue)
don't try to insert watchpoint. We don't automatically delete
such watchpoint, though, since failure to parse expression
is different from out-of-scope watchpoint. */
- if (!target_has_execution)
+ if (!target_has_execution ())
{
/* Without execution, memory can't change. No use to try and
set watchpoint locations. The watchpoint will be reset when
if we aren't attached to any process yet, we should still
insert breakpoints. */
if (!gdbarch_has_global_breakpoints (target_gdbarch ())
- && (inferior_ptid == null_ptid || !target_has_execution))
+ && (inferior_ptid == null_ptid || !target_has_execution ()))
continue;
val = insert_bp_location (bl, &tmp_error_stream, &disabled_breaks,
if we aren't attached to any process yet, we should still
insert breakpoints. */
if (!gdbarch_has_global_breakpoints (target_gdbarch ())
- && (inferior_ptid == null_ptid || !target_has_execution))
+ && (inferior_ptid == null_ptid || !target_has_execution ()))
continue;
val = insert_bp_location (bl, &tmp_error_stream, &disabled_breaks,
static thread_info *
get_bpstat_thread ()
{
- if (inferior_ptid == null_ptid || !target_has_execution)
+ if (inferior_ptid == null_ptid || !target_has_execution ())
return NULL;
thread_info *tp = inferior_thread ();
{
int binary_flag = 0;
- if (!target_has_execution)
+ if (!target_has_execution ())
noprocess ();
CORE_ADDR load_offset = 0;
struct gdbarch *gdbarch = get_current_arch ();
std::string triplet_rx;
- if (!target_has_execution)
+ if (!target_has_execution ())
error (_("The program must be running for the compile command to "\
"work."));
struct value *retval;
gdb::optional<enable_thread_stack_temporaries> stack_temporaries;
- if (*pos == 0 && target_has_execution
+ if (*pos == 0 && target_has_execution ()
&& exp->language_defn->la_language == language_cplus
&& !thread_stack_temporaries_enabled_p (inferior_thread ()))
stack_temporaries.emplace (inferior_thread ());
static void
exec_file_command (const char *args, int from_tty)
{
- if (from_tty && target_has_execution
+ if (from_tty && target_has_execution ()
&& !query (_("A program is being debugged already.\n"
"Are you sure you want to change the file? ")))
error (_("File not changed."));
gdb::unique_xmalloc_ptr<char> corefilename;
/* No use generating a corefile without a target process. */
- if (!target_has_execution)
+ if (!target_has_execution ())
noprocess ();
if (args && *args)
/* This function depends on being able to call a function in the
inferior. */
- if (!target_has_execution)
+ if (!target_has_execution ())
return 0;
/* The following code assumes that the link map is arranged as
/* Unregister the inferior from the event loop. This is done
so that when the inferior is not running we don't get
distracted by spurious inferior output. */
- if (target_has_execution && target_can_async_p ())
+ if (target_has_execution () && target_can_async_p ())
target_async (0);
}
error (_("Cannot call functions in the program: "
"may-call-functions is off."));
- if (!target_has_execution)
+ if (!target_has_execution ())
noprocess ();
if (get_traceframe_number () >= 0)
/* If the program has exited, or we stopped at a different thread,
exit and inform the user. */
- if (! target_has_execution)
+ if (! target_has_execution ())
{
const char *name = get_function_name (funaddr,
name_buf, sizeof (name_buf));
static void step_1 (int, int, const char *);
#define ERROR_NO_INFERIOR \
- if (!target_has_execution) error (_("The program is not being run."));
+ if (!target_has_execution ()) error (_("The program is not being run."));
/* Scratch area where string containing arguments to give to the
program will be stored by 'set args'. As soon as anything is
static void
kill_if_already_running (int from_tty)
{
- if (inferior_ptid != null_ptid && target_has_execution)
+ if (inferior_ptid != null_ptid && target_has_execution ())
{
/* Bail out before killing the program if we will not be able to
restart it. */
ptid_t ptid;
process_stratum_target *proc_target;
- if (!target_has_execution)
+ if (!target_has_execution ())
{
printf_filtered (_("The program being debugged is not being run.\n"));
return;
/* Don't complain if all processes share the same symbol
space. */
;
- else if (target_has_execution)
+ else if (target_has_execution ())
{
if (query (_("A program is being debugged already. Kill it? ")))
target_kill ();
{ return m_target_stack.at (stratum); }
bool has_execution ()
- { return target_has_execution_1 (this); }
+ { return target_has_execution (this); }
/* Pointer to next inferior in singly-linked list of inferiors. */
struct inferior *next = NULL;
set_non_stop (const char *args, int from_tty,
struct cmd_list_element *c)
{
- if (target_has_execution)
+ if (target_has_execution ())
{
non_stop_1 = non_stop;
error (_("Cannot change this setting while the inferior is running."));
set_observer_mode (const char *args, int from_tty,
struct cmd_list_element *c)
{
- if (target_has_execution)
+ if (target_has_execution ())
{
observer_mode_1 = observer_mode;
error (_("Cannot change this setting while the inferior is running."));
{
switch_to_inferior_no_thread (inf);
- if (!target_has_execution)
+ if (!target_has_execution ())
continue;
process_stratum_target *proc_target
static void
for_each_just_stopped_thread (for_each_just_stopped_thread_callback_func func)
{
- if (!target_has_execution || inferior_ptid == null_ptid)
+ if (!target_has_execution () || inferior_ptid == null_ptid)
return;
if (target_is_non_stop_p ())
void
maybe_remove_breakpoints (void)
{
- if (!breakpoints_should_be_inserted_now () && target_has_execution)
+ if (!breakpoints_should_be_inserted_now () && target_has_execution ())
{
if (remove_breakpoints ())
{
informing of a stop. */
if (!non_stop
&& previous_inferior_ptid != inferior_ptid
- && target_has_execution
+ && target_has_execution ()
&& last.kind != TARGET_WAITKIND_SIGNALLED
&& last.kind != TARGET_WAITKIND_EXITED
&& last.kind != TARGET_WAITKIND_NO_RESUMED)
annotate_stopped ();
- if (target_has_execution)
+ if (target_has_execution ())
{
if (last.kind != TARGET_WAITKIND_SIGNALLED
&& last.kind != TARGET_WAITKIND_EXITED
/* The inferior can be gone if the user types "print exit(0)"
(and perhaps other times). */
- if (target_has_execution)
+ if (target_has_execution ())
/* NB: The register write goes through to the target. */
regcache->restore (registers ());
}
struct fork_info *fp;
pid_t retpid;
- if (!target_has_execution)
+ if (!target_has_execution ())
error (_("The program is not being run."));
/* Ensure that the inferior is not multithreaded. */
}
else
{
- if (!target_has_execution)
+ if (!target_has_execution ())
error (_("No current process: you must name one."));
if (current_inferior ()->fake_pid_p)
error (_("Can't determine the current process's PID: you must name one."));
/* It doesn't make sense to access the host's /proc when debugging a
core file. Instead, look for the PT_LOAD segment that matches
the vDSO. */
- if (!target_has_execution)
+ if (!target_has_execution ())
{
long phdrs_size;
int num_phdrs, i;
/* The workaround works by reading from /proc/pid/status, so it is
disabled for core files. */
- if (target_has_execution)
+ if (target_has_execution ())
info->need_stale_parent_threads_check = 1;
info->next = thread_db_list;
corrupted. For core files it does not apply, no 'later enumeration'
is possible. */
- if (!target_has_execution || !inferior_has_bug ("nptl_version", 2, 7))
+ if (!target_has_execution () || !inferior_has_bug ("nptl_version", 2, 7))
{
exception_fprintf (gdb_stderr, except,
_("Warning: couldn't activate thread debugging "
memset (&th2, 23, sizeof (td_thrhandle_t));
CALL_UNCHECKED (td_ta_map_lwp2thr, th->th_ta_p, ti.ti_lid, &th2);
- if (tdb_testinfo->last_result == TD_ERR && !target_has_execution)
+ if (tdb_testinfo->last_result == TD_ERR && !target_has_execution ())
{
/* Some platforms require execution for td_ta_map_lwp2thr. */
LOG (_("; can't map_lwp2thr"));
td_ta_map_lwp2thr uses ps_get_thread_area, but we can't use that
currently on core targets, as it uses ptrace directly. */
- if (target_has_execution
+ if (target_has_execution ()
&& linux_proc_task_list_dir_exists (inferior_ptid.pid ()))
info->td_ta_thr_iter_p = NULL;
else
else
tp->priv.reset (priv);
- if (target_has_execution)
+ if (target_has_execution ())
check_thread_signals ();
return tp;
#include "value.h"
#include "symfile.h"
#include "objfiles.h"
-#include "target.h" /* for target_has_execution */
+#include "target.h"
#include "gdbcore.h"
#include "gdbcmd.h"
#include "frame.h"
struct type *char_type = builtin_type (gdbarch)->builtin_char;
struct value * function, *classval;
- if (! target_has_execution)
+ if (! target_has_execution ())
{
/* Can't call into inferior to lookup class. */
return 0;
struct type *char_type = builtin_type (gdbarch)->builtin_char;
struct value * function, *selstring;
- if (! target_has_execution)
+ if (! target_has_execution ())
{
/* Can't call into inferior to lookup selector. */
return 0;
struct symbol *sym;
struct type *type;
- if (!target_has_execution)
+ if (!target_has_execution ())
return 0; /* Can't call into inferior to create NSString. */
stringValue[2] = value_string(ptr, len, char_type);
record_preopen ();
- if (!target_has_execution)
+ if (!target_has_execution ())
error (_("The program is not being run."));
for (thread_info *tp : current_inferior ()->non_exited_threads ())
fprintf_unfiltered (gdb_stdlog, "Process record: record_full_open_1\n");
/* check exec */
- if (!target_has_execution)
+ if (!target_has_execution ())
error (_("Process record: the program is not being run."));
if (non_stop)
error (_("Process record target can't debug inferior in non-stop mode "
}
/* If we connected to a live target, do some additional setup. */
- if (target_has_execution)
+ if (target_has_execution ())
{
if (symfile_objfile) /* No use without a symbol-file. */
remote_check_symbols ();
but our current inferior is not running, we should not invite the
remote target to request symbol lookups related to its
(unrelated) current process. */
- if (!target_has_execution)
+ if (!target_has_execution ())
return;
if (packet_support (PACKET_qSymbol) == PACKET_DISABLE)
/* If we're connected to a running target, target_preopen will kill it.
Ask this question first, before target_preopen has a chance to kill
anything. */
- if (curr_remote != NULL && !target_has_execution)
+ if (curr_remote != NULL && !target_has_execution ())
{
if (from_tty
&& !query (_("Already connected to a remote target. Disconnect? ")))
struct remote_state *rs = get_remote_state ();
int is_fork_parent;
- if (!target_has_execution)
+ if (!target_has_execution ())
error (_("No process to detach from."));
target_announce_detach (from_tty);
/* It doesn't make sense to use qCRC if the remote target is
connected but not running. */
- if (target_has_execution && packet_support (PACKET_qCRC) != PACKET_DISABLE)
+ if (target_has_execution ()
+ && packet_support (PACKET_qCRC) != PACKET_DISABLE)
{
enum packet_result result;
/* If the remote target is connected but not running, we should
pass this request down to a lower stratum (e.g. the executable
file). */
- if (!target_has_execution)
+ if (!target_has_execution ())
return TARGET_XFER_EOF;
if (writebuf != NULL)
/* Do not try this during initial connection, when we do not know
whether there is a running but stopped thread. */
- if (!target_has_execution || inferior_ptid == null_ptid)
+ if (!target_has_execution () || inferior_ptid == null_ptid)
return beneath ()->read_description ();
if (!data->guesses.empty ())
/* If we're not debugging a process yet, the IPA can't be
loaded. */
- if (!target_has_execution)
+ if (!target_has_execution ())
return 0;
/* Make sure the remote is pointing at the right process. */
/* This function assumes that it is being run with a live process.
Core files are handled via gdbarch. */
- gdb_assert (target_has_execution);
+ gdb_assert (target_has_execution ());
if (writebuf)
return TARGET_XFER_E_IO;
int big;
int ret;
- if (target_has_execution && memblock != NULL)
+ if (target_has_execution () && memblock != NULL)
{
/* Fetch instruction from local MEMBLOCK. */
memcpy (buf, memblock, SCORE_INSTLEN);
if (exec_bfd == NULL)
return 0;
- if (!target_has_execution)
+ if (!target_has_execution ())
return 0;
info = get_dsbt_info ();
/* No point setting a breakpoint in the dynamic linker if we can't
hit it (e.g., a core file, or a trace file). */
- if (!target_has_execution)
+ if (!target_has_execution ())
return;
if (!svr4_have_link_map_offsets ())
/* We can reach here due to changing solib-search-path or the
sysroot, before having any inferior. */
- if (target_has_execution && inferior_ptid != null_ptid)
+ if (target_has_execution () && inferior_ptid != null_ptid)
{
struct inferior *inf = current_inferior ();
Absent this call, if we've just connected to a target and set
solib-absolute-prefix or solib-search-path, we'll lose all information
about ld.so. */
- if (target_has_execution)
+ if (target_has_execution ())
{
/* Reset or free private data structures not associated with
so_list entries. */
adi_examine_command (const char *args, int from_tty)
{
/* make sure program is active and adi is available */
- if (!target_has_execution)
+ if (!target_has_execution ())
error (_("ADI command requires a live process/thread"));
if (!adi_available ())
= N_("Usage: adi assign|a[/COUNT] ADDR = VERSION");
/* make sure program is active and adi is available */
- if (!target_has_execution)
+ if (!target_has_execution ())
error (_("ADI command requires a live process/thread"));
if (!adi_available ())
}
bool
-target_has_execution_1 (inferior *inf)
+target_has_execution (inferior *inf)
{
+ if (inf == nullptr)
+ inf = current_inferior ();
+
for (target_ops *t = inf->top_target ();
t != nullptr;
t = inf->find_target_beneath (t))
return false;
}
-int
-target_has_execution_current (void)
-{
- return target_has_execution_1 (current_inferior ());
-}
-
/* This is used to implement the various target commands. */
static void
if (current_inferior ()->pid != 0)
{
if (!from_tty
- || !target_has_execution
+ || !target_has_execution ()
|| query (_("A program is being debugged already. Kill it? ")))
{
/* Core inferiors actually should be detached, not
killed. */
- if (target_has_execution)
+ if (target_has_execution ())
target_kill ();
else
target_detach (current_inferior (), 0);
set_target_permissions (const char *args, int from_tty,
struct cmd_list_element *c)
{
- if (target_has_execution)
+ if (target_has_execution ())
{
update_target_permissions ();
error (_("Cannot change this setting while the inferior is running."));
whether or not the target is capable of execution, but there are
also targets which can be current while not executing. In that
case this will become true after to_create_inferior or
- to_attach. */
+ to_attach. INF is the inferior to use; nullptr means to use the
+ current inferior. */
-extern bool target_has_execution_1 (inferior *inf);
-
-/* Like target_has_execution_1, but always passes
- current_inferior(). */
-
-extern int target_has_execution_current (void);
-
-#define target_has_execution target_has_execution_current ()
+extern bool target_has_execution (inferior *inf = nullptr);
/* Can the target support the debugger control of thread execution?
Can it lock the thread scheduler? */
switch_to_thread (thread);
/* Leave core files alone. */
- if (target_has_execution)
+ if (target_has_execution ())
{
if (inf->attach_flag)
target_detach (inf, from_tty);
}
else
{
- if (!target_has_execution)
+ if (!target_has_execution ())
error (_("evaluation of this expression "
"requires the target program to be active"));
else
val = call_function_by_hand (val, NULL, blocklen);
if (value_logical_not (val))
{
- if (!target_has_execution)
+ if (!target_has_execution ())
error (_("No memory available to program now: "
"you need to start the target first"));
else
}
CORE_ADDR tlb;
gdb_byte buf[8];
- if (target_has_execution
+ if (target_has_execution ()
&& target_get_tib_address (inferior_ptid, &tlb)
&& !target_read_memory (tlb + peb_offset, buf, ptr_bytes))
{
projects / binutils-gdb.git / commitdiff