/* opncls.c -- open and close a BFD.
Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000,
- 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
+ 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012
Free Software Foundation, Inc.
Written by Cygnus Support.
#define S_IXOTH 0001 /* Execute by others. */
#endif
-/* Counter used to initialize the bfd identifier. */
+/* Counters used to initialize the bfd identifier. */
-static unsigned int _bfd_id_counter = 0;
+static unsigned int bfd_id_counter = 0;
+static unsigned int bfd_reserved_id_counter = 0;
+
+/*
+CODE_FRAGMENT
+.{* Set to N to open the next N BFDs using an alternate id space. *}
+.extern unsigned int bfd_use_reserved_id;
+*/
+unsigned int bfd_use_reserved_id = 0;
/* fdopen is a loser -- we should use stdio exclusively. Unfortunately
if we do that we can't use fcntl. */
if (nbfd == NULL)
return NULL;
- nbfd->id = _bfd_id_counter++;
+ if (bfd_use_reserved_id)
+ {
+ nbfd->id = --bfd_reserved_id_counter;
+ --bfd_use_reserved_id;
+ }
+ else
+ nbfd->id = bfd_id_counter++;
nbfd->memory = objalloc_create ();
if (nbfd->memory == NULL)
nbfd->iostream = NULL;
nbfd->where = 0;
if (!bfd_hash_table_init_n (& nbfd->section_htab, bfd_section_hash_newfunc,
- sizeof (struct section_hash_entry), 251))
+ sizeof (struct section_hash_entry), 13))
{
free (nbfd);
return NULL;
return nbfd;
}
+static const struct bfd_iovec opncls_iovec;
+
/* Allocate a new BFD as a member of archive OBFD. */
bfd *
return NULL;
nbfd->xvec = obfd->xvec;
nbfd->iovec = obfd->iovec;
+ if (obfd->iovec == &opncls_iovec)
+ nbfd->iostream = obfd->iostream;
nbfd->my_archive = obfd;
nbfd->direction = read_direction;
nbfd->target_defaulted = obfd->target_defaulted;
/* Delete a BFD. */
-void
+static void
_bfd_delete_bfd (bfd *abfd)
{
if (abfd->memory)
bfd_hash_table_free (&abfd->section_htab);
objalloc_free ((struct objalloc *) abfd->memory);
}
+
+ free (abfd->arelt_data);
free (abfd);
}
Return a pointer to the created BFD. If @var{fd} is not -1,
then <<fdopen>> is used to open the file; otherwise, <<fopen>>
is used. @var{mode} is passed directly to <<fopen>> or
- <<fdopen>>.
+ <<fdopen>>.
Calls <<bfd_find_target>>, so @var{target} is interpreted as by
that function.
If <<NULL>> is returned then an error has occured. Possible errors
are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
<<system_call>> error.
+
+ On error, @var{fd} is always closed.
*/
bfd *
nbfd = _bfd_new_bfd ();
if (nbfd == NULL)
- return NULL;
+ {
+ if (fd != -1)
+ close (fd);
+ return NULL;
+ }
target_vec = bfd_find_target (target, nbfd);
if (target_vec == NULL)
{
+ if (fd != -1)
+ close (fd);
_bfd_delete_bfd (nbfd);
return NULL;
}
-
+
#ifdef HAVE_FDOPEN
if (fd != -1)
nbfd->iostream = fdopen (fd, mode);
/* Figure out whether the user is opening the file for reading,
writing, or both, by looking at the MODE argument. */
- if ((mode[0] == 'r' || mode[0] == 'w' || mode[0] == 'a')
+ if ((mode[0] == 'r' || mode[0] == 'w' || mode[0] == 'a')
&& mode[1] == '+')
nbfd->direction = both_direction;
else if (mode[0] == 'r')
Possible errors are <<bfd_error_no_memory>>,
<<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
+
+ On error, @var{fd} is closed.
*/
bfd *
fdflags = fcntl (fd, F_GETFL, NULL);
if (fdflags == -1)
{
+ int save = errno;
+
+ close (fd);
+ errno = save;
bfd_set_error (bfd_error_system_call);
return NULL;
}
SYNOPSIS
bfd *bfd_openr_iovec (const char *filename, const char *target,
- void *(*open) (struct bfd *nbfd,
- void *open_closure),
+ void *(*open_func) (struct bfd *nbfd,
+ void *open_closure),
void *open_closure,
- file_ptr (*pread) (struct bfd *nbfd,
- void *stream,
- void *buf,
- file_ptr nbytes,
- file_ptr offset),
- int (*close) (struct bfd *nbfd,
- void *stream),
- int (*stat) (struct bfd *abfd,
- void *stream,
- struct stat *sb));
+ file_ptr (*pread_func) (struct bfd *nbfd,
+ void *stream,
+ void *buf,
+ file_ptr nbytes,
+ file_ptr offset),
+ int (*close_func) (struct bfd *nbfd,
+ void *stream),
+ int (*stat_func) (struct bfd *abfd,
+ void *stream,
+ struct stat *sb));
DESCRIPTION
Create and return a BFD backed by a read-only @var{stream}.
- The @var{stream} is created using @var{open}, accessed using
- @var{pread} and destroyed using @var{close}.
+ The @var{stream} is created using @var{open_func}, accessed using
+ @var{pread_func} and destroyed using @var{close_func}.
Calls <<bfd_find_target>>, so @var{target} is interpreted as by
that function.
- Calls @var{open} (which can call <<bfd_zalloc>> and
+ Calls @var{open_func} (which can call <<bfd_zalloc>> and
<<bfd_get_filename>>) to obtain the read-only stream backing
- the BFD. @var{open} either succeeds returning the
+ the BFD. @var{open_func} either succeeds returning the
non-<<NULL>> @var{stream}, or fails returning <<NULL>>
(setting <<bfd_error>>).
- Calls @var{pread} to request @var{nbytes} of data from
+ Calls @var{pread_func} to request @var{nbytes} of data from
@var{stream} starting at @var{offset} (e.g., via a call to
- <<bfd_read>>). @var{pread} either succeeds returning the
+ <<bfd_read>>). @var{pread_func} either succeeds returning the
number of bytes read (which can be less than @var{nbytes} when
end-of-file), or fails returning -1 (setting <<bfd_error>>).
- Calls @var{close} when the BFD is later closed using
- <<bfd_close>>. @var{close} either succeeds returning 0, or
+ Calls @var{close_func} when the BFD is later closed using
+ <<bfd_close>>. @var{close_func} 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
+ Calls @var{stat_func} to fill in a stat structure for bfd_stat,
+ bfd_get_size, and bfd_get_mtime calls. @var{stat_func} returns 0
on success, or returns -1 on failure (setting <<bfd_error>>).
If <<bfd_openr_iovec>> returns <<NULL>> then an error has
bfd_size_type len ATTRIBUTE_UNUSED,
int prot ATTRIBUTE_UNUSED,
int flags ATTRIBUTE_UNUSED,
- file_ptr offset ATTRIBUTE_UNUSED)
+ file_ptr offset ATTRIBUTE_UNUSED,
+ void **map_addr ATTRIBUTE_UNUSED,
+ bfd_size_type *map_len ATTRIBUTE_UNUSED)
{
return (void *) -1;
}
bfd *
bfd_openr_iovec (const char *filename, const char *target,
- void *(*open) (struct bfd *nbfd,
- void *open_closure),
+ void *(*open_p) (struct bfd *, void *),
void *open_closure,
- file_ptr (*pread) (struct bfd *abfd,
- void *stream,
- void *buf,
- file_ptr nbytes,
- file_ptr offset),
- int (*close) (struct bfd *nbfd,
- void *stream),
- int (*stat) (struct bfd *abfd,
- void *stream,
- struct stat *sb))
+ file_ptr (*pread_p) (struct bfd *, void *, void *,
+ file_ptr, file_ptr),
+ int (*close_p) (struct bfd *, void *),
+ int (*stat_p) (struct bfd *, void *, struct stat *))
{
bfd *nbfd;
const bfd_target *target_vec;
nbfd->filename = filename;
nbfd->direction = read_direction;
- /* `open (...)' would get expanded by an the open(2) syscall macro. */
- stream = (*open) (nbfd, open_closure);
+ /* `open_p (...)' would get expanded by an the open(2) syscall macro. */
+ stream = (*open_p) (nbfd, open_closure);
if (stream == NULL)
{
_bfd_delete_bfd (nbfd);
vec = (struct opncls *) bfd_zalloc (nbfd, sizeof (struct opncls));
vec->stream = stream;
- vec->pread = pread;
- vec->close = close;
- vec->stat = stat;
+ vec->pread = pread_p;
+ vec->close = close_p;
+ vec->stat = stat_p;
nbfd->iovec = &opncls_iovec;
nbfd->iostream = vec;
/* If the file was open for writing and is now executable,
make it so. */
if (abfd->direction == write_direction
- && abfd->flags & EXEC_P)
+ && (abfd->flags & (EXEC_P | DYNAMIC)) != 0)
{
struct stat buf;
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;
- if ((abfd->flags & BFD_IN_MEMORY) != 0)
- {
- /* FIXME: cagney/2004-02-15: Need to implement a BFD_IN_MEMORY io
- vector.
- Until that's done, at least don't leak memory. */
- struct bfd_in_memory *bim = (struct bfd_in_memory *) abfd->iostream;
- free (bim->buffer);
- free (bim);
- ret = TRUE;
- }
- else
- ret = abfd->iovec->bclose (abfd);
+ ret = abfd->iovec->bclose (abfd) == 0;
if (ret)
_maybe_make_executable (abfd);
DESCRIPTION
Create a new BFD in the manner of <<bfd_openw>>, but without
opening a file. The new BFD takes the target from the target
- used by @var{template}. The format is always set to <<bfd_object>>.
+ used by @var{templ}. The format is always set to <<bfd_object>>.
*/
bfd *
bim->buffer = 0;
abfd->flags |= BFD_IN_MEMORY;
+ abfd->iovec = &_bfd_memory_iovec;
+ abfd->origin = 0;
abfd->direction = write_direction;
abfd->where = 0;
if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
return FALSE;
-
abfd->arch_info = &bfd_default_arch_struct;
abfd->where = 0;
abfd->section_count = 0;
abfd->usrdata = NULL;
abfd->cacheable = FALSE;
- abfd->flags = BFD_IN_MEMORY;
+ abfd->flags |= BFD_IN_MEMORY;
abfd->mtime_set = FALSE;
abfd->target_defaulted = TRUE;
}
/*
-INTERNAL_FUNCTION
+FUNCTION
bfd_alloc
SYNOPSIS
}
/*
-INTERNAL_FUNCTION
+FUNCTION
bfd_zalloc
SYNOPSIS
crc = ~crc & 0xffffffff;
for (end = buf + len; buf < end; ++ buf)
crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
- return ~crc & 0xffffffff;;
+ return ~crc & 0xffffffff;
}
static char *
find_separate_debug_file (bfd *abfd, const char *debug_file_directory)
{
- char *basename;
+ char *base;
char *dir;
char *debugfile;
char *canon_dir;
return NULL;
}
- basename = get_debug_link_info (abfd, & crc32);
- if (basename == NULL)
+ base = get_debug_link_info (abfd, & crc32);
+ if (base == NULL)
return NULL;
- if (basename[0] == '\0')
+ if (base[0] == '\0')
{
- free (basename);
+ free (base);
bfd_set_error (bfd_error_no_debug_section);
return NULL;
}
dir = (char *) bfd_malloc (dirlen + 1);
if (dir == NULL)
{
- free (basename);
+ free (base);
return NULL;
}
memcpy (dir, abfd->filename, dirlen);
bfd_malloc (strlen (debug_file_directory) + 1
+ (canon_dirlen > dirlen ? canon_dirlen : dirlen)
+ strlen (".debug/")
- + strlen (basename)
+ + strlen (base)
+ 1);
if (debugfile == NULL)
{
- free (basename);
+ free (base);
free (dir);
free (canon_dir);
return NULL;
/* First try in the same directory as the original file: */
strcpy (debugfile, dir);
- strcat (debugfile, basename);
+ strcat (debugfile, base);
if (separate_debug_file_exists (debugfile, crc32))
{
- free (basename);
+ free (base);
free (dir);
free (canon_dir);
return debugfile;
/* Then try in a subdirectory called .debug. */
strcpy (debugfile, dir);
strcat (debugfile, ".debug/");
- strcat (debugfile, basename);
+ strcat (debugfile, base);
if (separate_debug_file_exists (debugfile, crc32))
{
- free (basename);
+ free (base);
free (dir);
free (canon_dir);
return debugfile;
&& canon_dir[0] != '/')
strcat (debugfile, "/");
strcat (debugfile, canon_dir);
- strcat (debugfile, basename);
+ strcat (debugfile, base);
if (separate_debug_file_exists (debugfile, crc32))
{
- free (basename);
+ free (base);
free (dir);
free (canon_dir);
return debugfile;
}
free (debugfile);
- free (basename);
+ free (base);
free (dir);
free (canon_dir);
return NULL;
projects / deliverable / binutils-gdb.git / blobdiff