/* Core dump and executable file functions below target vector, for GDB.
- Copyright (C) 1986-2014 Free Software Foundation, Inc.
+ Copyright (C) 1986-2015 Free Software Foundation, Inc.
This file is part of GDB.
#include "symfile.h"
#include "exec.h"
#include "readline/readline.h"
-#include "exceptions.h"
#include "solib.h"
#include "filenames.h"
#include "progspace.h"
/* Don't sniff if we have support for register sets in
CORE_GDBARCH. */
- if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
+ if (core_gdbarch && gdbarch_iterate_over_regset_sections_p (core_gdbarch))
return NULL;
for (cf = core_file_fns; cf != NULL; cf = cf->next)
int fake_pid_p = 0;
struct inferior *inf;
- if (strncmp (bfd_section_name (abfd, asect), ".reg/", 5) != 0)
+ if (!startswith (bfd_section_name (abfd, asect), ".reg/"))
return;
core_tid = atoi (bfd_section_name (abfd, asect) + 5);
bfd *temp_bfd;
int scratch_chan;
int flags;
- volatile struct gdb_exception except;
char *filename;
target_preopen (from_tty);
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)
+ TRY
{
- target_find_new_threads ();
+ target_update_thread_list ();
}
- if (except.reason < 0)
- exception_print (gdb_stderr, except);
+ CATCH (except, RETURN_MASK_ERROR)
+ {
+ exception_print (gdb_stderr, except);
+ }
+ END_CATCH
p = bfd_core_file_failing_command (core_bfd);
if (p)
/* 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 (except, RETURN_MASK_ERROR)
+ {
+ exception_print (gdb_stderr, except);
+ }
+ END_CATCH
+ }
}
static void
static void
get_core_register_section (struct regcache *regcache,
+ const struct regset *regset,
const char *name,
+ int min_size,
int which,
const char *human_name,
int required)
}
size = bfd_section_size (core_bfd, section);
- contents = alloca (size);
+ if (size < min_size)
+ {
+ warning (_("Section `%s' in core file too small."), section_name);
+ return;
+ }
+ if (size != min_size && !(regset->flags & REGSET_VARIABLE_SIZE))
+ {
+ warning (_("Unexpected size of section `%s' in core file."),
+ section_name);
+ }
+
+ contents = (char *) alloca (size);
if (! bfd_get_section_contents (core_bfd, section, contents,
(file_ptr) 0, size))
{
return;
}
- if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
+ if (regset != NULL)
{
- const struct regset *regset;
-
- regset = gdbarch_regset_from_core_section (core_gdbarch,
- name, size);
- if (regset == NULL)
- {
- if (required)
- warning (_("Couldn't recognize %s registers in core file."),
- human_name);
- return;
- }
-
regset->supply_regset (regset, regcache, -1, contents, size);
return;
}
static void
get_core_registers_cb (const char *sect_name, int size,
+ const struct regset *regset,
const char *human_name, void *cb_data)
{
struct regcache *regcache = (struct regcache *) cb_data;
+ int required = 0;
if (strcmp (sect_name, ".reg") == 0)
- get_core_register_section (regcache, sect_name, 0, human_name, 1);
+ {
+ required = 1;
+ if (human_name == NULL)
+ human_name = "general-purpose";
+ }
else if (strcmp (sect_name, ".reg2") == 0)
- get_core_register_section (regcache, sect_name, 2, human_name, 0);
- else
- get_core_register_section (regcache, sect_name, 3, human_name, 0);
+ {
+ if (human_name == NULL)
+ human_name = "floating-point";
+ }
+
+ /* The 'which' parameter is only used when no regset is provided.
+ Thus we just set it to -1. */
+ get_core_register_section (regcache, regset, sect_name,
+ size, -1, human_name, required);
}
/* Get the registers out of a core file. This is the machine-
int i;
struct gdbarch *gdbarch;
- if (!(core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
+ if (!(core_gdbarch && gdbarch_iterate_over_regset_sections_p (core_gdbarch))
&& (core_vec == NULL || core_vec->core_read_registers == NULL))
{
fprintf_filtered (gdb_stderr,
(void *) regcache, NULL);
else
{
- get_core_register_section (regcache,
- ".reg", 0, "general-purpose", 1);
- get_core_register_section (regcache,
- ".reg2", 2, "floating-point", 0);
+ get_core_register_section (regcache, NULL,
+ ".reg", 0, 0, "general-purpose", 1);
+ get_core_register_section (regcache, NULL,
+ ".reg2", 0, 2, "floating-point", 0);
}
/* Mark all registers not found in the core as unavailable. */
static void
add_to_spuid_list (bfd *abfd, asection *asect, void *list_p)
{
- struct spuid_list *list = list_p;
+ struct spuid_list *list = (struct spuid_list *) list_p;
enum bfd_endian byte_order
= bfd_big_endian (abfd) ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
int fd, pos = 0;
/* Otherwise, this isn't a "threaded" core -- use the PID field, but
only if it isn't a fake PID. */
- inf = find_inferior_pid (ptid_get_pid (ptid));
+ inf = find_inferior_ptid (ptid);
if (inf != NULL && !inf->fake_pid_p)
return normal_pid_to_str (ptid);