GDB 7.6.50

bfd/opncls.c

 /* 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, 2010, 2012
-   Free Software Foundation, Inc.
+   Copyright 1990-2013 Free Software Foundation, Inc.
 
    Written by Cygnus Support.
 
    This file is part of BFD, the Binary File Descriptor library.
 
    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 3 of the License, or
    (at your option) any later version.
 
@@ skipping 60 matching lines @@
   nbfd->memory = objalloc_create ();
   if (nbfd->memory == NULL)
     {
       bfd_set_error (bfd_error_no_memory);
       free (nbfd);
       return NULL;
     }
 
   nbfd->arch_info = &bfd_default_arch_struct;
 
-  nbfd->direction = no_direction;
-  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;
     }
-  nbfd->sections = NULL;
-  nbfd->section_last = NULL;
-  nbfd->format = bfd_unknown;
-  nbfd->my_archive = NULL;
-  nbfd->origin = 0;
-  nbfd->opened_once = FALSE;
-  nbfd->output_has_begun = FALSE;
-  nbfd->section_count = 0;
-  nbfd->usrdata = NULL;
-  nbfd->cacheable = FALSE;
-  nbfd->flags = BFD_NO_FLAGS;
-  nbfd->mtime_set = FALSE;
 
   return nbfd;
 }
 
+static const struct bfd_iovec opncls_iovec;
+
 /* Allocate a new BFD as a member of archive OBFD.  */
 
 bfd *
 _bfd_new_bfd_contained_in (bfd *obfd)
 {
   bfd *nbfd;
 
   nbfd = _bfd_new_bfd ();
   if (nbfd == NULL)
     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;
   return nbfd;
 }
 
 /* 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);
 }
 
 /* Free objalloc memory.  */
 
 bfd_boolean
 _bfd_free_cached_info (bfd *abfd)
 {
   if (abfd->memory)
     {
@@ skipping 25 matching lines @@
 
 SYNOPSIS
         bfd *bfd_fopen (const char *filename, const char *target,
                         const char *mode, int fd);
 
 DESCRIPTION
         Open the file @var{filename} with the target @var{target}.
         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.
 
         The new BFD is marked as cacheable iff @var{fd} is -1.
 
         If <<NULL>> is returned then an error has occured.   Possible errors
         are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
         <<system_call>> error.
 
@@ skipping 15 matching lines @@
     }
 
   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);
   else
 #endif
     nbfd->iostream = real_fopen (filename, mode);
   if (nbfd->iostream == NULL)
     {
       bfd_set_error (bfd_error_system_call);
       _bfd_delete_bfd (nbfd);
       return NULL;
     }
 
   /* OK, put everything where it belongs.  */
   nbfd->filename = filename;
 
   /* 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')
     nbfd->direction = read_direction;
   else
     nbfd->direction = write_direction;
 
   if (! bfd_cache_init (nbfd))
     {
       _bfd_delete_bfd (nbfd);
       return NULL;
     }
   nbfd->opened_once = TRUE;
+
   /* If we opened the file by name, mark it cacheable; we can close it
      and reopen it later.  However, if a file descriptor was provided,
      then it may have been opened with special flags that make it
      unsafe to close and reopen the file.  */
   if (fd == -1)
-    bfd_set_cacheable (nbfd, TRUE);
+    (void) bfd_set_cacheable (nbfd, TRUE);
 
   return nbfd;
 }
 
 /*
 FUNCTION
         bfd_openr
 
 SYNOPSIS
         bfd *bfd_openr (const char *filename, const char *target);
@@ skipping 429 matching lines @@
         All memory attached to the BFD is released.
 
         The file descriptor associated with the BFD is closed (even
         if it was passed in to BFD by <<bfd_fdopenr>>).
 
 RETURNS
         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
 */