static void
add_to_thread_list (bfd *abfd, asection *asect, void *reg_sect_arg)
{
ptid_t ptid;
int core_tid;
int pid, lwpid;
asection *reg_sect = (asection *) reg_sect_arg;
if (strncmp (bfd_section_name (abfd, asect), ".reg/", 5) != 0)
return;
core_tid = atoi (bfd_section_name (abfd, asect) + 5);
pid = bfd_core_file_pid (core_bfd);
if (pid == 0)
{
core_has_fake_pid = 1;
pid = CORELOW_PID;
}
lwpid = core_tid;
if (current_inferior ()->pid == 0)
inferior_appeared (current_inferior (), pid);
ptid = ptid_build (pid, lwpid, 0);
add_thread (ptid);
/* Warning, Will Robinson, looking at BFD private data! */
if (reg_sect != NULL
&& asect->filepos == reg_sect->filepos) /* Did we find .reg? */
inferior_ptid = ptid; /* Yes, make it current. */
}
static void
inf_ptrace_attach (struct target_ops *ops, char *args, int from_tty)
{
char *exec_file;
pid_t pid;
struct inferior *inf;
/* Do not change either targets above or the same target if already present.
The reason is the target stack is shared across multiple inferiors. */
int ops_already_pushed = target_is_pushed (ops);
struct cleanup *back_to = NULL;
pid = parse_pid_to_attach (args);
if (pid == getpid ()) /* Trying to m********e? */
error (_("I refuse to debug myself!"));
if (! ops_already_pushed)
{
/* target_pid_to_str already uses the target. Also clear possible core
file with its process_stratum. */
push_target (ops);
back_to = make_cleanup_unpush_target (ops);
}
if (from_tty)
{
exec_file = get_exec_file (0);
if (exec_file)
printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
target_pid_to_str (pid_to_ptid (pid)));
else
printf_unfiltered (_("Attaching to %s\n"),
target_pid_to_str (pid_to_ptid (pid)));
gdb_flush (gdb_stdout);
}
#ifdef PT_ATTACH
errno = 0;
ptrace (PT_ATTACH, pid, (PTRACE_TYPE_ARG3)0, 0);
if (errno != 0)
perror_with_name (("ptrace"));
#else
error (_("This system does not support attaching to a process"));
#endif
inf = current_inferior ();
inferior_appeared (inf, pid);
inf->attach_flag = 1;
inferior_ptid = pid_to_ptid (pid);
/* Always add a main thread. If some target extends the ptrace
target, it should decorate the ptid later with more info. */
add_thread_silent (inferior_ptid);
if (! ops_already_pushed)
discard_cleanups (back_to);
}
static void
add_to_thread_list (bfd *abfd, asection *asect, void *reg_sect_arg)
{
ptid_t ptid;
int core_tid;
int pid, lwpid;
asection *reg_sect = (asection *) reg_sect_arg;
int fake_pid_p = 0;
struct inferior *inf;
if (!startswith (bfd_section_name (abfd, asect), ".reg/"))
return;
core_tid = atoi (bfd_section_name (abfd, asect) + 5);
pid = bfd_core_file_pid (core_bfd);
if (pid == 0)
{
fake_pid_p = 1;
pid = CORELOW_PID;
}
lwpid = core_tid;
inf = current_inferior ();
if (inf->pid == 0)
{
inferior_appeared (inf, pid);
inf->fake_pid_p = fake_pid_p;
}
ptid = ptid_build (pid, lwpid, 0);
add_thread (ptid);
/* Warning, Will Robinson, looking at BFD private data! */
if (reg_sect != NULL
&& asect->filepos == reg_sect->filepos) /* Did we find .reg? */
inferior_ptid = ptid; /* Yes, make it current. */
}
static void
core_open (char *filename, int from_tty)
{
const char *p;
int siggy;
struct cleanup *old_chain;
char *temp;
bfd *temp_bfd;
int scratch_chan;
int flags;
volatile struct gdb_exception except;
target_preopen (from_tty);
if (!filename)
{
if (core_bfd)
error (_("No core file specified. (Use `detach' "
"to stop debugging a core file.)"));
else
error (_("No core file specified."));
}
filename = tilde_expand (filename);
if (!IS_ABSOLUTE_PATH (filename))
{
temp = concat (current_directory, "/",
filename, (char *) NULL);
xfree (filename);
filename = temp;
}
old_chain = make_cleanup (xfree, filename);
flags = O_BINARY | O_LARGEFILE;
if (write_files)
flags |= O_RDWR;
else
flags |= O_RDONLY;
scratch_chan = open (filename, flags, 0);
if (scratch_chan < 0)
perror_with_name (filename);
temp_bfd = bfd_fopen (filename, gnutarget,
write_files ? FOPEN_RUB : FOPEN_RB,
scratch_chan);
if (temp_bfd == NULL)
perror_with_name (filename);
if (!bfd_check_format (temp_bfd, bfd_core)
&& !gdb_check_format (temp_bfd))
{
/* Do it after the err msg */
/* FIXME: should be checking for errors from bfd_close (for one
thing, on error it does not free all the storage associated
with the bfd). */
make_cleanup_bfd_close (temp_bfd);
error (_("\"%s\" is not a core dump: %s"),
filename, bfd_errmsg (bfd_get_error ()));
}
/* Looks semi-reasonable. Toss the old core file and work on the
new. */
discard_cleanups (old_chain); /* Don't free filename any more */
unpush_target (&core_ops);
core_bfd = temp_bfd;
old_chain = make_cleanup (core_close_cleanup, 0 /*ignore*/);
/* FIXME: kettenis/20031023: This is very dangerous. The
CORE_GDBARCH that results from this call may very well be
different from CURRENT_GDBARCH. However, its methods may only
work if it is selected as the current architecture, because they
rely on swapped data (see gdbarch.c). We should get rid of that
swapped data. */
core_gdbarch = gdbarch_from_bfd (core_bfd);
/* Find a suitable core file handler to munch on core_bfd */
core_vec = sniff_core_bfd (core_bfd);
validate_files ();
core_data = XZALLOC (struct target_section_table);
/* Find the data section */
if (build_section_table (core_bfd,
&core_data->sections,
&core_data->sections_end))
error (_("\"%s\": Can't find sections: %s"),
bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
/* If we have no exec file, try to set the architecture from the
core file. We don't do this unconditionally since an exec file
typically contains more information that helps us determine the
architecture than a core file. */
if (!exec_bfd)
set_gdbarch_from_file (core_bfd);
push_target (&core_ops);
discard_cleanups (old_chain);
/* Do this before acknowledging the inferior, so if
post_create_inferior throws (can happen easilly if you're loading
a core file with the wrong exec), we aren't left with threads
from the previous inferior. */
init_thread_list ();
inferior_ptid = null_ptid;
/* Need to flush the register cache (and the frame cache) from a
previous debug session. If inferior_ptid ends up the same as the
last debug session --- e.g., b foo; run; gcore core1; step; gcore
core2; core core1; core core2 --- then there's potential for
get_current_regcache to return the cached regcache of the
previous session, and the frame cache being stale. */
registers_changed ();
/* Build up thread list from BFD sections, and possibly set the
current thread to the .reg/NN section matching the .reg
section. */
bfd_map_over_sections (core_bfd, add_to_thread_list,
bfd_get_section_by_name (core_bfd, ".reg"));
if (ptid_equal (inferior_ptid, null_ptid))
{
/* Either we found no .reg/NN section, and hence we have a
non-threaded core (single-threaded, from gdb's perspective),
or for some reason add_to_thread_list couldn't determine
which was the "main" thread. The latter case shouldn't
usually happen, but we're dealing with input here, which can
always be broken in different ways. */
struct thread_info *thread = first_thread_of_process (-1);
if (thread == NULL)
{
inferior_appeared (current_inferior (), CORELOW_PID);
inferior_ptid = pid_to_ptid (CORELOW_PID);
add_thread_silent (inferior_ptid);
}
else
switch_to_thread (thread->ptid);
}
post_create_inferior (&core_ops, from_tty);
/* Now go through the target stack looking for threads since there
may be a thread_stratum target loaded on top of target core by
now. The layer above should claim threads found in the BFD
sections. */
TRY_CATCH (except, RETURN_MASK_ERROR)
{
target_find_new_threads ();
}
if (except.reason < 0)
exception_print (gdb_stderr, except);
p = bfd_core_file_failing_command (core_bfd);
if (p)
printf_filtered (_("Core was generated by `%s'.\n"), p);
siggy = bfd_core_file_failing_signal (core_bfd);
if (siggy > 0)
{
/* If we don't have a CORE_GDBARCH to work with, assume a native
core (map gdb_signal from host signals). If we do have
CORE_GDBARCH to work with, but no gdb_signal_from_target
implementation for that gdbarch, as a fallback measure,
assume the host signal mapping. It'll be correct for native
cores, but most likely incorrect for cross-cores. */
enum gdb_signal sig = (core_gdbarch != NULL
&& gdbarch_gdb_signal_from_target_p (core_gdbarch)
? gdbarch_gdb_signal_from_target (core_gdbarch,
siggy)
: gdb_signal_from_host (siggy));
printf_filtered (_("Program terminated with signal %d, %s.\n"),
siggy, gdb_signal_to_string (sig));
}
/* Fetch all registers from core file. */
target_fetch_registers (get_current_regcache (), -1);
/* Now, set up the frame cache, and print the top of stack. */
reinit_frame_cache ();
print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
}
int
fork_inferior (char *exec_file_arg, char *allargs, char **env,
void (*traceme_fun) (void), void (*init_trace_fun) (int),
void (*pre_trace_fun) (void), char *shell_file_arg)
{
int pid;
char *shell_command;
static char default_shell_file[] = SHELL_FILE;
int len;
/* Set debug_fork then attach to the child while it sleeps, to debug. */
static int debug_fork = 0;
/* This is set to the result of setpgrp, which if vforked, will be visible
to you in the parent process. It's only used by humans for debugging. */
static int debug_setpgrp = 657473;
static char *shell_file;
static char *exec_file;
char **save_our_env;
int shell = 0;
static char **argv;
const char *inferior_io_terminal = get_inferior_io_terminal ();
struct inferior *inf;
/* If no exec file handed to us, get it from the exec-file command
-- with a good, common error message if none is specified. */
exec_file = exec_file_arg;
if (exec_file == 0)
exec_file = get_exec_file (1);
/* STARTUP_WITH_SHELL is defined in inferior.h. If 0,e we'll just
do a fork/exec, no shell, so don't bother figuring out what
shell. */
shell_file = shell_file_arg;
if (STARTUP_WITH_SHELL)
{
/* Figure out what shell to start up the user program under. */
if (shell_file == NULL)
shell_file = getenv ("SHELL");
if (shell_file == NULL)
shell_file = default_shell_file;
shell = 1;
}
/* Multiplying the length of exec_file by 4 is to account for the
fact that it may expand when quoted; it is a worst-case number
based on every character being '. */
len = 5 + 4 * strlen (exec_file) + 1 + strlen (allargs) + 1 + /*slop */ 12;
if (exec_wrapper)
len += strlen (exec_wrapper) + 1;
shell_command = (char *) alloca (len);
shell_command[0] = '\0';
if (!shell)
{
/* We're going to call execvp. Create argument vector.
Calculate an upper bound on the length of the vector by
assuming that every other character is a separate
argument. */
int argc = (strlen (allargs) + 1) / 2 + 2;
argv = (char **) xmalloc (argc * sizeof (*argv));
argv[0] = exec_file;
breakup_args (allargs, &argv[1]);
}
else
{
/* We're going to call a shell. */
char *p;
int need_to_quote;
const int escape_bang = escape_bang_in_quoted_argument (shell_file);
strcat (shell_command, "exec ");
/* Add any exec wrapper. That may be a program name with arguments, so
the user must handle quoting. */
if (exec_wrapper)
{
strcat (shell_command, exec_wrapper);
strcat (shell_command, " ");
}
/* Now add exec_file, quoting as necessary. */
/* Quoting in this style is said to work with all shells. But
csh on IRIX 4.0.1 can't deal with it. So we only quote it if
we need to. */
p = exec_file;
while (1)
{
switch (*p)
{
case '\'':
case '!':
case '"':
case '(':
case ')':
case '$':
case '&':
case ';':
case '<':
case '>':
case ' ':
case '\n':
case '\t':
need_to_quote = 1;
goto end_scan;
case '\0':
need_to_quote = 0;
goto end_scan;
default:
break;
}
++p;
}
end_scan:
if (need_to_quote)
{
strcat (shell_command, "'");
for (p = exec_file; *p != '\0'; ++p)
{
if (*p == '\'')
strcat (shell_command, "'\\''");
else if (*p == '!' && escape_bang)
strcat (shell_command, "\\!");
else
strncat (shell_command, p, 1);
}
strcat (shell_command, "'");
}
else
strcat (shell_command, exec_file);
strcat (shell_command, " ");
strcat (shell_command, allargs);
}
/* On some systems an exec will fail if the executable is open. */
close_exec_file ();
/* Retain a copy of our environment variables, since the child will
replace the value of environ and if we're vforked, we have to
restore it. */
save_our_env = environ;
/* Tell the terminal handling subsystem what tty we plan to run on;
it will just record the information for later. */
new_tty_prefork (inferior_io_terminal);
/* It is generally good practice to flush any possible pending stdio
output prior to doing a fork, to avoid the possibility of both
the parent and child flushing the same data after the fork. */
gdb_flush (gdb_stdout);
gdb_flush (gdb_stderr);
/* If there's any initialization of the target layers that must
happen to prepare to handle the child we're about fork, do it
now... */
if (pre_trace_fun != NULL)
(*pre_trace_fun) ();
/* Create the child process. Since the child process is going to
exec(3) shortly afterwards, try to reduce the overhead by
calling vfork(2). However, if PRE_TRACE_FUN is non-null, it's
likely that this optimization won't work since there's too much
work to do between the vfork(2) and the exec(3). This is known
to be the case on ttrace(2)-based HP-UX, where some handshaking
between parent and child needs to happen between fork(2) and
exec(2). However, since the parent is suspended in the vforked
state, this doesn't work. Also note that the vfork(2) call might
actually be a call to fork(2) due to the fact that autoconf will
``#define vfork fork'' on certain platforms. */
if (pre_trace_fun || debug_fork)
pid = fork ();
else
pid = vfork ();
if (pid < 0)
perror_with_name (("vfork"));
if (pid == 0)
{
if (debug_fork)
sleep (debug_fork);
/* Create a new session for the inferior process, if necessary.
It will also place the inferior in a separate process group. */
if (create_tty_session () <= 0)
{
/* No session was created, but we still want to run the inferior
in a separate process group. */
debug_setpgrp = gdb_setpgid ();
if (debug_setpgrp == -1)
perror (_("setpgrp failed in child"));
}
/* Ask the tty subsystem to switch to the one we specified
earlier (or to share the current terminal, if none was
specified). */
new_tty ();
/* Changing the signal handlers for the inferior after
a vfork can also change them for the superior, so we don't mess
with signals here. See comments in
initialize_signals for how we get the right signal handlers
for the inferior. */
/* "Trace me, Dr. Memory!" */
(*traceme_fun) ();
/* The call above set this process (the "child") as debuggable
by the original gdb process (the "parent"). Since processes
(unlike people) can have only one parent, if you are debugging
gdb itself (and your debugger is thus _already_ the
controller/parent for this child), code from here on out is
undebuggable. Indeed, you probably got an error message
saying "not parent". Sorry; you'll have to use print
statements! */
/* There is no execlpe call, so we have to set the environment
for our child in the global variable. If we've vforked, this
clobbers the parent, but environ is restored a few lines down
in the parent. By the way, yes we do need to look down the
path to find $SHELL. Rich Pixley says so, and I agree. */
environ = env;
/* If we decided above to start up with a shell, we exec the
shell, "-c" says to interpret the next arg as a shell command
to execute, and this command is "exec <target-program>
<args>". */
if (shell)
{
execlp (shell_file, shell_file, "-c", shell_command, (char *) 0);
/* If we get here, it's an error. */
fprintf_unfiltered (gdb_stderr, "Cannot exec %s: %s.\n", shell_file,
safe_strerror (errno));
gdb_flush (gdb_stderr);
_exit (0177);
}
else
{
/* Otherwise, we directly exec the target program with
execvp. */
int i;
execvp (exec_file, argv);
/* If we get here, it's an error. */
safe_strerror (errno);
fprintf_unfiltered (gdb_stderr, "Cannot exec %s ", exec_file);
i = 1;
while (argv[i] != NULL)
{
if (i != 1)
fprintf_unfiltered (gdb_stderr, " ");
fprintf_unfiltered (gdb_stderr, "%s", argv[i]);
i++;
}
fprintf_unfiltered (gdb_stderr, ".\n");
gdb_flush (gdb_stderr);
_exit (0177);
}
}
/* Restore our environment in case a vforked child clob'd it. */
environ = save_our_env;
if (!have_inferiors ())
init_thread_list ();
inf = current_inferior ();
inferior_appeared (inf, pid);
/* Needed for wait_for_inferior stuff below. */
inferior_ptid = pid_to_ptid (pid);
new_tty_postfork ();
/* We have something that executes now. We'll be running through
the shell at this point, but the pid shouldn't change. Targets
supporting MT should fill this task's ptid with more data as soon
as they can. */
add_thread_silent (inferior_ptid);
/* Now that we have a child process, make it our target, and
initialize anything target-vector-specific that needs
initializing. */
if (init_trace_fun)
(*init_trace_fun) (pid);
/* We are now in the child process of interest, having exec'd the
correct program, and are poised at the first instruction of the
new program. */
return pid;
}
static void
core_open (const char *arg, int from_tty)
{
const char *p;
int siggy;
struct cleanup *old_chain;
char *temp;
int scratch_chan;
int flags;
char *filename;
target_preopen (from_tty);
if (!arg)
{
if (core_bfd)
error (_("No core file specified. (Use `detach' "
"to stop debugging a core file.)"));
else
error (_("No core file specified."));
}
filename = tilde_expand (arg);
if (!IS_ABSOLUTE_PATH (filename))
{
temp = concat (current_directory, "/",
filename, (char *) NULL);
xfree (filename);
filename = temp;
}
old_chain = make_cleanup (xfree, filename);
flags = O_BINARY | O_LARGEFILE;
if (write_files)
flags |= O_RDWR;
else
flags |= O_RDONLY;
scratch_chan = gdb_open_cloexec (filename, flags, 0);
if (scratch_chan < 0)
perror_with_name (filename);
gdb_bfd_ref_ptr temp_bfd (gdb_bfd_fopen (filename, gnutarget,
write_files ? FOPEN_RUB : FOPEN_RB,
scratch_chan));
if (temp_bfd == NULL)
perror_with_name (filename);
if (!bfd_check_format (temp_bfd.get (), bfd_core)
&& !gdb_check_format (temp_bfd.get ()))
{
/* Do it after the err msg */
/* FIXME: should be checking for errors from bfd_close (for one
thing, on error it does not free all the storage associated
with the bfd). */
error (_("\"%s\" is not a core dump: %s"),
filename, bfd_errmsg (bfd_get_error ()));
}
/* Looks semi-reasonable. Toss the old core file and work on the
new. */
do_cleanups (old_chain);
unpush_target (&core_ops);
core_bfd = temp_bfd.release ();
old_chain = make_cleanup (core_close_cleanup, 0 /*ignore*/);
core_gdbarch = gdbarch_from_bfd (core_bfd);
/* Find a suitable core file handler to munch on core_bfd */
core_vec = sniff_core_bfd (core_bfd);
validate_files ();
core_data = XCNEW (struct target_section_table);
/* Find the data section */
if (build_section_table (core_bfd,
&core_data->sections,
&core_data->sections_end))
error (_("\"%s\": Can't find sections: %s"),
bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
/* If we have no exec file, try to set the architecture from the
core file. We don't do this unconditionally since an exec file
typically contains more information that helps us determine the
architecture than a core file. */
if (!exec_bfd)
set_gdbarch_from_file (core_bfd);
push_target (&core_ops);
discard_cleanups (old_chain);
/* Do this before acknowledging the inferior, so if
post_create_inferior throws (can happen easilly if you're loading
a core file with the wrong exec), we aren't left with threads
from the previous inferior. */
init_thread_list ();
inferior_ptid = null_ptid;
/* Need to flush the register cache (and the frame cache) from a
previous debug session. If inferior_ptid ends up the same as the
last debug session --- e.g., b foo; run; gcore core1; step; gcore
core2; core core1; core core2 --- then there's potential for
get_current_regcache to return the cached regcache of the
previous session, and the frame cache being stale. */
registers_changed ();
/* Build up thread list from BFD sections, and possibly set the
current thread to the .reg/NN section matching the .reg
section. */
bfd_map_over_sections (core_bfd, add_to_thread_list,
bfd_get_section_by_name (core_bfd, ".reg"));
if (ptid_equal (inferior_ptid, null_ptid))
{
/* Either we found no .reg/NN section, and hence we have a
non-threaded core (single-threaded, from gdb's perspective),
or for some reason add_to_thread_list couldn't determine
which was the "main" thread. The latter case shouldn't
usually happen, but we're dealing with input here, which can
always be broken in different ways. */
struct thread_info *thread = first_thread_of_process (-1);
if (thread == NULL)
{
inferior_appeared (current_inferior (), CORELOW_PID);
inferior_ptid = pid_to_ptid (CORELOW_PID);
add_thread_silent (inferior_ptid);
}
else
switch_to_thread (thread->ptid);
}
post_create_inferior (&core_ops, from_tty);
/* Now go through the target stack looking for threads since there
may be a thread_stratum target loaded on top of target core by
now. The layer above should claim threads found in the BFD
sections. */
TRY
{
target_update_thread_list ();
}
CATCH (except, RETURN_MASK_ERROR)
{
exception_print (gdb_stderr, except);
}
void
inf_ptrace_target::attach (const char *args, int from_tty)
{
char *exec_file;
pid_t pid;
struct inferior *inf;
/* Do not change either targets above or the same target if already present.
The reason is the target stack is shared across multiple inferiors. */
int ops_already_pushed = target_is_pushed (this);
pid = parse_pid_to_attach (args);
if (pid == getpid ()) /* Trying to m********e? */
error (_("I refuse to debug myself!"));
target_unpush_up unpusher;
if (! ops_already_pushed)
{
/* target_pid_to_str already uses the target. Also clear possible core
file with its process_stratum. */
push_target (this);
unpusher.reset (this);
}
if (from_tty)
{
exec_file = get_exec_file (0);
if (exec_file)
printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
target_pid_to_str (ptid_t (pid)));
else
printf_unfiltered (_("Attaching to %s\n"),
target_pid_to_str (ptid_t (pid)));
gdb_flush (gdb_stdout);
}
#ifdef PT_ATTACH
errno = 0;
ptrace (PT_ATTACH, pid, (PTRACE_TYPE_ARG3)0, 0);
if (errno != 0)
perror_with_name (("ptrace"));
#else
error (_("This system does not support attaching to a process"));
#endif
inf = current_inferior ();
inferior_appeared (inf, pid);
inf->attach_flag = 1;
inferior_ptid = ptid_t (pid);
/* Always add a main thread. If some target extends the ptrace
target, it should decorate the ptid later with more info. */
thread_info *thr = add_thread_silent (inferior_ptid);
/* Don't consider the thread stopped until we've processed its
initial SIGSTOP stop. */
set_executing (thr->ptid, true);
unpusher.release ();
}
void
core_target_open (const char *arg, int from_tty)
{
const char *p;
int siggy;
int scratch_chan;
int flags;
target_preopen (from_tty);
if (!arg)
{
if (core_bfd)
error (_("No core file specified. (Use `detach' "
"to stop debugging a core file.)"));
else
error (_("No core file specified."));
}
gdb::unique_xmalloc_ptr<char> filename (tilde_expand (arg));
if (!IS_ABSOLUTE_PATH (filename.get ()))
filename.reset (concat (current_directory, "/",
filename.get (), (char *) NULL));
flags = O_BINARY | O_LARGEFILE;
if (write_files)
flags |= O_RDWR;
else
flags |= O_RDONLY;
scratch_chan = gdb_open_cloexec (filename.get (), flags, 0);
if (scratch_chan < 0)
perror_with_name (filename.get ());
gdb_bfd_ref_ptr temp_bfd (gdb_bfd_fopen (filename.get (), gnutarget,
write_files ? FOPEN_RUB : FOPEN_RB,
scratch_chan));
if (temp_bfd == NULL)
perror_with_name (filename.get ());
if (!bfd_check_format (temp_bfd.get (), bfd_core)
&& !gdb_check_format (temp_bfd.get ()))
{
/* Do it after the err msg */
/* FIXME: should be checking for errors from bfd_close (for one
thing, on error it does not free all the storage associated
with the bfd). */
error (_("\"%s\" is not a core dump: %s"),
filename.get (), bfd_errmsg (bfd_get_error ()));
}
current_program_space->cbfd = std::move (temp_bfd);
core_target *target = new core_target ();
/* Own the target until it is successfully pushed. */
target_ops_up target_holder (target);
validate_files ();
/* If we have no exec file, try to set the architecture from the
core file. We don't do this unconditionally since an exec file
typically contains more information that helps us determine the
architecture than a core file. */
if (!exec_bfd)
set_gdbarch_from_file (core_bfd);
push_target (std::move (target_holder));
inferior_ptid = null_ptid;
/* Need to flush the register cache (and the frame cache) from a
previous debug session. If inferior_ptid ends up the same as the
last debug session --- e.g., b foo; run; gcore core1; step; gcore
core2; core core1; core core2 --- then there's potential for
get_current_regcache to return the cached regcache of the
previous session, and the frame cache being stale. */
registers_changed ();
/* Build up thread list from BFD sections, and possibly set the
current thread to the .reg/NN section matching the .reg
section. */
bfd_map_over_sections (core_bfd, add_to_thread_list,
bfd_get_section_by_name (core_bfd, ".reg"));
if (inferior_ptid == null_ptid)
{
/* Either we found no .reg/NN section, and hence we have a
non-threaded core (single-threaded, from gdb's perspective),
or for some reason add_to_thread_list couldn't determine
which was the "main" thread. The latter case shouldn't
usually happen, but we're dealing with input here, which can
always be broken in different ways. */
thread_info *thread = first_thread_of_inferior (current_inferior ());
if (thread == NULL)
{
inferior_appeared (current_inferior (), CORELOW_PID);
inferior_ptid = ptid_t (CORELOW_PID);
add_thread_silent (inferior_ptid);
}
else
switch_to_thread (thread);
}
post_create_inferior (target, from_tty);
/* Now go through the target stack looking for threads since there
may be a thread_stratum target loaded on top of target core by
now. The layer above should claim threads found in the BFD
sections. */
try
{
target_update_thread_list ();
}
catch (const gdb_exception_error &except)
{
exception_print (gdb_stderr, except);
}
p = bfd_core_file_failing_command (core_bfd);
if (p)
printf_filtered (_("Core was generated by `%s'.\n"), p);
/* Clearing any previous state of convenience variables. */
clear_exit_convenience_vars ();
siggy = bfd_core_file_failing_signal (core_bfd);
if (siggy > 0)
{
gdbarch *core_gdbarch = target->core_gdbarch ();
/* If we don't have a CORE_GDBARCH to work with, assume a native
core (map gdb_signal from host signals). If we do have
CORE_GDBARCH to work with, but no gdb_signal_from_target
implementation for that gdbarch, as a fallback measure,
assume the host signal mapping. It'll be correct for native
cores, but most likely incorrect for cross-cores. */
enum gdb_signal sig = (core_gdbarch != NULL
&& gdbarch_gdb_signal_from_target_p (core_gdbarch)
? gdbarch_gdb_signal_from_target (core_gdbarch,
siggy)
: gdb_signal_from_host (siggy));
printf_filtered (_("Program terminated with signal %s, %s.\n"),
gdb_signal_to_name (sig), gdb_signal_to_string (sig));
/* Set the value of the internal variable $_exitsignal,
which holds the signal uncaught by the inferior. */
set_internalvar_integer (lookup_internalvar ("_exitsignal"),
siggy);
}
/* Fetch all registers from core file. */
target_fetch_registers (get_current_regcache (), -1);
/* Now, set up the frame cache, and print the top of stack. */
reinit_frame_cache ();
print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
/* Current thread should be NUM 1 but the user does not know that.
If a program is single threaded gdb in general does not mention
anything about threads. That is why the test is >= 2. */
if (thread_count () >= 2)
{
try
{
thread_command (NULL, from_tty);
}
catch (const gdb_exception_error &except)
{
exception_print (gdb_stderr, except);
}
}
}
static void
ctf_open (const char *dirname, int from_tty)
{
struct bt_ctf_event *event;
uint32_t event_id;
const struct bt_definition *scope;
struct uploaded_tsv *uploaded_tsvs = NULL;
struct uploaded_tp *uploaded_tps = NULL;
if (!dirname)
error (_("No CTF directory specified."));
ctf_open_dir (dirname);
target_preopen (from_tty);
/* Skip the first packet which about the trace status. The first
event is "frame". */
event = bt_ctf_iter_read_event (ctf_iter);
scope = bt_ctf_get_top_level_scope (event, BT_STREAM_EVENT_HEADER);
event_id = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope, "id"));
if (event_id != CTF_EVENT_ID_FRAME)
error (_("Wrong event id of the first event"));
/* The second event is "status". */
bt_iter_next (bt_ctf_get_iter (ctf_iter));
event = bt_ctf_iter_read_event (ctf_iter);
scope = bt_ctf_get_top_level_scope (event, BT_STREAM_EVENT_HEADER);
event_id = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope, "id"));
if (event_id != CTF_EVENT_ID_STATUS)
error (_("Wrong event id of the second event"));
ctf_read_status (event, current_trace_status ());
ctf_read_tsv (&uploaded_tsvs);
ctf_read_tp (&uploaded_tps);
event = bt_ctf_iter_read_event (ctf_iter);
/* EVENT can be NULL if we've already gone to the end of stream of
events. */
if (event != NULL)
{
scope = bt_ctf_get_top_level_scope (event,
BT_STREAM_EVENT_HEADER);
event_id = bt_ctf_get_uint64 (bt_ctf_get_field (event,
scope, "id"));
if (event_id != CTF_EVENT_ID_FRAME)
error (_("Wrong event id of the first event of the second packet"));
}
start_pos = bt_iter_get_pos (bt_ctf_get_iter (ctf_iter));
gdb_assert (start_pos->type == BT_SEEK_RESTORE);
trace_dirname = xstrdup (dirname);
push_target (&ctf_ops);
inferior_appeared (current_inferior (), CTF_PID);
inferior_ptid = pid_to_ptid (CTF_PID);
add_thread_silent (inferior_ptid);
merge_uploaded_trace_state_variables (&uploaded_tsvs);
merge_uploaded_tracepoints (&uploaded_tps);
post_create_inferior (&ctf_ops, from_tty);
}
static void
kgdb_trgt_open(char *filename, int from_tty)
{
struct cleanup *old_chain;
struct kthr *kt;
struct inferior *inf8;
struct program_space *pspace;
kvm_t *nkvm;
char *temp;
int first_inferior = 1;
target_preopen (from_tty);
if (!filename)
error ("No vmcore file specified.");
if (!exec_bfd)
error ("Can't open a vmcore without a kernel");
filename = tilde_expand (filename);
if (filename[0] != '/') {
temp = concat (current_directory, "/", filename, NULL);
xfree(filename);
filename = temp;
}
old_chain = make_cleanup (xfree, filename);
nkvm = kvm_openfiles(bfd_get_filename(exec_bfd), filename, NULL,
write_files ? O_RDWR : O_RDONLY, kvm_err);
if (nkvm == NULL)
error ("Failed to open vmcore: %s", kvm_err);
/* Don't free the filename now and close any previous vmcore. */
discard_cleanups(old_chain);
unpush_target(&kgdb_trgt_ops);
kvm = nkvm;
vmcore = filename;
old_chain = make_cleanup(kgdb_core_cleanup, NULL);
push_target (&kgdb_trgt_ops);
discard_cleanups (old_chain);
kgdb_dmesg();
init_thread_list();
kt = kgdb_thr_init();
while (kt != NULL) {
if (!in_inferior_list(kt->pid)) {
if (first_inferior) {
first_inferior = 0;
inf8 = current_inferior();
inf8->pid = kt->pid;
inferior_appeared (inf8, kt->pid);
pspace = current_program_space;
pspace->ebfd = 0;
pspace->ebfd_mtime = 0;
} else {
inf8 = add_inferior(kt->pid);
pspace = add_program_space(new_address_space());
pspace->symfile_object_file = symfile_objfile;
pspace->objfiles = object_files;
}
inf8->pspace = pspace;
inf8->aspace = pspace->aspace;
}
add_thread(ptid_build(kt->pid, 0, kt->tid));
kt = kgdb_thr_next(kt);
}
if (curkthr != 0)
inferior_ptid = ptid_build(curkthr->pid, 0, curkthr->tid);
frame_unwind_prepend_unwinder(get_frame_arch(get_current_frame()), &kgdb_trgt_trapframe_unwind);
/* XXX: fetch registers? */
kld_init();
reinit_frame_cache();
select_frame (get_current_frame());
print_stack_frame(get_selected_frame(NULL),
frame_relative_level(get_selected_frame(NULL)), 1);
}
