/* opncls.c -- open and close a BFD.
Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000,
- 2001, 2002, 2003, 2004, 2005
+ 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
Free Software Foundation, Inc.
Written by Cygnus Support.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
+ Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+ MA 02110-1301, USA. */
-#include "bfd.h"
#include "sysdep.h"
+#include "bfd.h"
#include "objalloc.h"
#include "libbfd.h"
#include "libiberty.h"
nbfd->iostream = NULL;
nbfd->where = 0;
if (!bfd_hash_table_init_n (& nbfd->section_htab, bfd_section_hash_newfunc,
- 251))
+ sizeof (struct section_hash_entry), 251))
{
free (nbfd);
return NULL;
void
_bfd_delete_bfd (bfd *abfd)
{
- bfd_hash_table_free (&abfd->section_htab);
- objalloc_free ((struct objalloc *) abfd->memory);
+ if (abfd->memory)
+ {
+ bfd_hash_table_free (&abfd->section_htab);
+ objalloc_free ((struct objalloc *) abfd->memory);
+ }
free (abfd);
}
+/* Free objalloc memory. */
+
+bfd_boolean
+_bfd_free_cached_info (bfd *abfd)
+{
+ if (abfd->memory)
+ {
+ bfd_hash_table_free (&abfd->section_htab);
+ objalloc_free ((struct objalloc *) abfd->memory);
+
+ abfd->sections = NULL;
+ abfd->section_last = NULL;
+ abfd->outsymbols = NULL;
+ abfd->tdata.any = NULL;
+ abfd->usrdata = NULL;
+ abfd->memory = NULL;
+ }
+
+ return TRUE;
+}
+
/*
SECTION
Opening and closing BFDs
+SUBSECTION
+ Functions for opening and closing
*/
/*
nbfd->iostream = fdopen (fd, mode);
else
#endif
- nbfd->iostream = fopen (filename, mode);
+ nbfd->iostream = real_fopen (filename, mode);
if (nbfd->iostream == NULL)
{
bfd_set_error (bfd_error_system_call);
file_ptr nbytes,
file_ptr offset),
int (*close) (struct bfd *nbfd,
- void *stream));
+ void *stream),
+ int (*stat) (struct bfd *abfd,
+ void *stream,
+ struct stat *sb));
DESCRIPTION
<<bfd_close>>. @var{close} either succeeds returning 0, or
fails returning -1 (setting <<bfd_error>>).
+ Calls @var{stat} to fill in a stat structure for bfd_stat,
+ bfd_get_size, and bfd_get_mtime calls. @var{stat} returns 0
+ on success, or returns -1 on failure (setting <<bfd_error>>).
+
If <<bfd_openr_iovec>> returns <<NULL>> then an error has
occurred. Possible errors are <<bfd_error_no_memory>>,
<<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
file_ptr (*pread) (struct bfd *abfd, void *stream, void *buf,
file_ptr nbytes, file_ptr offset);
int (*close) (struct bfd *abfd, void *stream);
+ int (*stat) (struct bfd *abfd, void *stream, struct stat *sb);
file_ptr where;
};
}
static int
-opncls_bstat (struct bfd *abfd ATTRIBUTE_UNUSED, struct stat *sb)
+opncls_bstat (struct bfd *abfd, struct stat *sb)
{
+ struct opncls *vec = abfd->iostream;
+
memset (sb, 0, sizeof (*sb));
- return 0;
+ if (vec->stat == NULL)
+ return 0;
+
+ return (vec->stat) (abfd, vec->stream, sb);
}
static const struct bfd_iovec opncls_iovec = {
file_ptr nbytes,
file_ptr offset),
int (*close) (struct bfd *nbfd,
- void *stream))
+ void *stream),
+ int (*stat) (struct bfd *abfd,
+ void *stream,
+ struct stat *sb))
{
bfd *nbfd;
const bfd_target *target_vec;
nbfd->filename = filename;
nbfd->direction = read_direction;
- stream = open (nbfd, open_closure);
+ /* `open (...)' would get expanded by an the open(2) syscall macro. */
+ stream = (*open) (nbfd, open_closure);
if (stream == NULL)
{
_bfd_delete_bfd (nbfd);
vec->stream = stream;
vec->pread = pread;
vec->close = close;
+ vec->stat = stat;
nbfd->iovec = &opncls_iovec;
nbfd->iostream = vec;
bfd_close (bfd *abfd)
{
bfd_boolean ret;
+ bfd *nbfd;
+ bfd *next;
if (bfd_write_p (abfd))
{
return FALSE;
}
+ /* Close nested archives (if this bfd is a thin archive). */
+ for (nbfd = abfd->nested_archives; nbfd; nbfd = next)
+ {
+ next = nbfd->archive_next;
+ bfd_close (nbfd);
+ }
+
if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
return FALSE;
}
bim = bfd_malloc (sizeof (struct bfd_in_memory));
+ if (bim == NULL)
+ return FALSE; /* bfd_error already set. */
abfd->iostream = bim;
/* bfd_bwrite will grow these as needed. */
bim->size = 0;
return ret;
}
+/*
+INTERNAL_FUNCTION
+ bfd_alloc2
+
+SYNOPSIS
+ void *bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
+
+DESCRIPTION
+ Allocate a block of @var{nmemb} elements of @var{size} bytes each
+ of memory attached to <<abfd>> and return a pointer to it.
+*/
+
+void *
+bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size)
+{
+ void *ret;
+
+ if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
+ && size != 0
+ && nmemb > ~(bfd_size_type) 0 / size)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ return NULL;
+ }
+
+ size *= nmemb;
+
+ if (size != (unsigned long) size)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ return NULL;
+ }
+
+ ret = objalloc_alloc (abfd->memory, (unsigned long) size);
+ if (ret == NULL)
+ bfd_set_error (bfd_error_no_memory);
+ return ret;
+}
+
/*
INTERNAL_FUNCTION
bfd_zalloc
return res;
}
+/*
+INTERNAL_FUNCTION
+ bfd_zalloc2
+
+SYNOPSIS
+ void *bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
+
+DESCRIPTION
+ Allocate a block of @var{nmemb} elements of @var{size} bytes each
+ of zeroed memory attached to <<abfd>> and return a pointer to it.
+*/
+
+void *
+bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size)
+{
+ void *res;
+
+ if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
+ && size != 0
+ && nmemb > ~(bfd_size_type) 0 / size)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ return NULL;
+ }
+
+ size *= nmemb;
+
+ res = bfd_alloc (abfd, size);
+ if (res)
+ memset (res, 0, (size_t) size);
+ return res;
+}
+
/* Free a block allocated for a BFD.
Note: Also frees all more recently allocated blocks! */
{
static unsigned char buffer [8 * 1024];
unsigned long file_crc = 0;
- int fd;
+ FILE *f;
bfd_size_type count;
BFD_ASSERT (name);
- fd = open (name, O_RDONLY);
- if (fd < 0)
+ f = real_fopen (name, FOPEN_RB);
+ if (f == NULL)
return FALSE;
- while ((count = read (fd, buffer, sizeof (buffer))) > 0)
+ while ((count = fread (buffer, 1, sizeof (buffer), f)) > 0)
file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
- close (fd);
+ fclose (f);
return crc == file_crc;
}
char *basename;
char *dir;
char *debugfile;
+ char *canon_dir;
unsigned long crc32;
- int i;
+ size_t dirlen;
+ size_t canon_dirlen;
BFD_ASSERT (abfd);
if (debug_file_directory == NULL)
debug_file_directory = ".";
/* BFD may have been opened from a stream. */
- if (! abfd->filename)
- return NULL;
+ if (abfd->filename == NULL)
+ {
+ bfd_set_error (bfd_error_invalid_operation);
+ return NULL;
+ }
basename = get_debug_link_info (abfd, & crc32);
if (basename == NULL)
return NULL;
- if (strlen (basename) < 1)
+ if (basename[0] == '\0')
{
free (basename);
+ bfd_set_error (bfd_error_no_debug_section);
return NULL;
}
- dir = strdup (abfd->filename);
+ for (dirlen = strlen (abfd->filename); dirlen > 0; dirlen--)
+ if (IS_DIR_SEPARATOR (abfd->filename[dirlen - 1]))
+ break;
+
+ dir = bfd_malloc (dirlen + 1);
if (dir == NULL)
{
free (basename);
return NULL;
}
- BFD_ASSERT (strlen (dir) != 0);
-
- /* Strip off filename part. */
- for (i = strlen (dir) - 1; i >= 0; i--)
- if (IS_DIR_SEPARATOR (dir[i]))
+ memcpy (dir, abfd->filename, dirlen);
+ dir[dirlen] = '\0';
+
+ /* Compute the canonical name of the bfd object with all symbolic links
+ resolved, for use in the global debugfile directory. */
+ canon_dir = lrealpath (abfd->filename);
+ for (canon_dirlen = strlen (canon_dir); canon_dirlen > 0; canon_dirlen--)
+ if (IS_DIR_SEPARATOR (canon_dir[canon_dirlen - 1]))
break;
+ canon_dir[canon_dirlen] = '\0';
- dir[i + 1] = '\0';
- BFD_ASSERT (dir[i] == '/' || dir[0] == '\0');
-
- debugfile = malloc (strlen (debug_file_directory) + 1
- + strlen (dir)
- + strlen (".debug/")
- + strlen (basename)
- + 1);
+ debugfile = bfd_malloc (strlen (debug_file_directory) + 1
+ + (canon_dirlen > dirlen ? canon_dirlen : dirlen)
+ + strlen (".debug/")
+ + strlen (basename)
+ + 1);
if (debugfile == NULL)
{
free (basename);
free (dir);
+ free (canon_dir);
return NULL;
}
{
free (basename);
free (dir);
+ free (canon_dir);
return debugfile;
}
{
free (basename);
free (dir);
+ free (canon_dir);
return debugfile;
}
/* Then try in the global debugfile directory. */
strcpy (debugfile, debug_file_directory);
- i = strlen (debug_file_directory) - 1;
- if (i > 0
- && debug_file_directory[i] != '/'
- && dir[0] != '/')
+ dirlen = strlen (debug_file_directory) - 1;
+ if (dirlen > 0
+ && debug_file_directory[dirlen] != '/'
+ && canon_dir[0] != '/')
strcat (debugfile, "/");
- strcat (debugfile, dir);
+ strcat (debugfile, canon_dir);
strcat (debugfile, basename);
if (separate_debug_file_exists (debugfile, crc32))
{
free (basename);
free (dir);
+ free (canon_dir);
return debugfile;
}
free (debugfile);
free (basename);
free (dir);
+ free (canon_dir);
return NULL;
}
{
asection *sect;
bfd_size_type debuglink_size;
+ flagword flags;
if (abfd == NULL || filename == NULL)
{
return NULL;
}
- sect = bfd_make_section (abfd, GNU_DEBUGLINK);
+ flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
+ sect = bfd_make_section_with_flags (abfd, GNU_DEBUGLINK, flags);
if (sect == NULL)
return NULL;
- if (! bfd_set_section_flags (abfd, sect,
- SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING))
- /* XXX Should we delete the section from the bfd ? */
- return NULL;
-
-
debuglink_size = strlen (filename) + 1;
debuglink_size += 3;
debuglink_size &= ~3;
FILE * handle;
static unsigned char buffer[8 * 1024];
size_t count;
+ size_t filelen;
if (abfd == NULL || sect == NULL || filename == NULL)
{
.gnu_debuglink section, we insist upon the user providing us with a
correct-for-section-creation-time path, but this need not conform to
the gdb location algorithm. */
- handle = fopen (filename, FOPEN_RB);
+ handle = real_fopen (filename, FOPEN_RB);
if (handle == NULL)
{
bfd_set_error (bfd_error_system_call);
now that we no longer need them. */
filename = lbasename (filename);
- debuglink_size = strlen (filename) + 1;
+ filelen = strlen (filename);
+ debuglink_size = filelen + 1;
debuglink_size += 3;
debuglink_size &= ~3;
debuglink_size += 4;
- contents = malloc (debuglink_size);
+ contents = bfd_malloc (debuglink_size);
if (contents == NULL)
{
/* XXX Should we delete the section from the bfd ? */
- bfd_set_error (bfd_error_no_memory);
return FALSE;
}
- strcpy (contents, filename);
crc_offset = debuglink_size - 4;
+ memcpy (contents, filename, filelen);
+ memset (contents + filelen, 0, crc_offset - filelen);
bfd_put_32 (abfd, crc32, contents + crc_offset);