FreeChainXenon/binutils-gdb
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Fix get_core_register_section leak, introduce thread_section_name

Browse source 
This plugs a leak introduced in the previous change to
get_core_register_section, which removed an xfree call that is
actually necessary because the 'section_name' local is static.

From [1] it looks like the reason the variable was made static to
begin with, was just "laziness" to avoid having to think about freeing
it on every function return path:

 https://sourceware.org/ml/gdb-patches/2005-03/msg00237.html

The easiest to fix that nowadays is to use a std::string.

I don't see a need to xstrdup the section name in the single-threaded
case though, and also there's more than one place that computes a
multi-threaded section name in the same way.  So put the section name
computation in a wrapper class with state.

gdb/ChangeLog:
2017-05-04  Pedro Alves  <palves@redhat.com>

	* corelow.c (thread_section_name): New class.
	(get_core_register_section, get_core_siginfo): Use it.
This commit is contained in:
Pedro Alves 2017-05-04 15:14:37 +01:00
parent f91d48deb2
commit 3c3ae77e68
2 changed files with 58 additions and 23 deletions
Download patch file Download diff file Expand all files Collapse all files

76
gdb/corelow.c
View file

@ -485,6 +485,51 @@ core_detach (struct target_ops *ops, const char *args, int from_tty)
printf_filtered (_("No core file now.\n"));
}
/* Build either a single-thread or multi-threaded section name for
PTID.
If ptid's lwp member is zero, we want to do the single-threaded
thing: look for a section named NAME (as passed to the
constructor). If ptid's lwp member is non-zero, we'll want do the
multi-threaded thing: look for a section named "NAME/LWP", where
LWP is the shortest ASCII decimal representation of ptid's lwp
member. */
class thread_section_name
{
public:
/* NAME is the single-threaded section name. If PTID represents an
LWP, then the build section name is "NAME/LWP", otherwise it's
just "NAME" unmodified. */
thread_section_name (const char *name, ptid_t ptid)
{
if (ptid.lwp_p ())
{
m_storage = string_printf ("%s/%ld", name, ptid.lwp ());
m_section_name = m_storage.c_str ();
}
else
m_section_name = name;
}
/* Return the computed section name. The result is valid as long as
this thread_section_name object is live. */
const char *c_str () const
{ return m_section_name; }
/* Disable copy. */
thread_section_name (const thread_section_name &) = delete;
void operator= (const thread_section_name &) = delete;
private:
/* Either a pointer into M_STORAGE, or a pointer to the name passed
as parameter to the constructor. */
const char *m_section_name;
/* If we need to build a new section name, this is where we store
it. */
std::string m_storage;
};
/* Try to retrieve registers from a section in core_bfd, and supply
them to core_vec->core_read_registers, as the register set numbered
WHICH.
@ -511,21 +556,15 @@ get_core_register_section (struct regcache *regcache,
const char *human_name,
int required)
{
static char *section_name;
struct bfd_section *section;
bfd_size_type size;
char *contents;
bool variable_size_section = (regset != NULL
&& regset->flags & REGSET_VARIABLE_SIZE);
ptid_t ptid = regcache_get_ptid (regcache);
if (ptid_get_lwp (ptid))
section_name = xstrprintf ("%s/%ld", name,
ptid_get_lwp (ptid));
else
section_name = xstrdup (name);
thread_section_name section_name (name, regcache->ptid ());
section = bfd_get_section_by_name (core_bfd, section_name);
section = bfd_get_section_by_name (core_bfd, section_name.c_str ());
if (! section)
{
if (required)
@ -537,13 +576,14 @@ get_core_register_section (struct regcache *regcache,
size = bfd_section_size (core_bfd, section);
if (size < min_size)
{
warning (_("Section `%s' in core file too small."), section_name);
warning (_("Section `%s' in core file too small."),
section_name.c_str ());
return;
}
if (size != min_size && !variable_size_section)
{
warning (_("Unexpected size of section `%s' in core file."),
section_name);
section_name.c_str ());
}
contents = (char *) alloca (size);
@ -551,7 +591,7 @@ get_core_register_section (struct regcache *regcache,
(file_ptr) 0, size))
{
warning (_("Couldn't read %s registers from `%s' section in core file."),
human_name, name);
human_name, section_name.c_str ());
return;
}
@ -681,18 +721,8 @@ add_to_spuid_list (bfd *abfd, asection *asect, void *list_p)
static LONGEST
get_core_siginfo (bfd *abfd, gdb_byte *readbuf, ULONGEST offset, ULONGEST len)
{
asection *section;
char *section_name;
const char *name = ".note.linuxcore.siginfo";
if (ptid_get_lwp (inferior_ptid))
section_name = xstrprintf ("%s/%ld", name,
ptid_get_lwp (inferior_ptid));
else
section_name = xstrdup (name);
section = bfd_get_section_by_name (abfd, section_name);
xfree (section_name);
thread_section_name section_name (".note.linuxcore.siginfo", inferior_ptid);
asection *section = bfd_get_section_by_name (abfd, section_name.c_str ());
if (section == NULL)
return -1;