gdb/

[deliverable/binutils-gdb.git] / gdb / exec.c

diff --git a/gdb/exec.c b/gdb/exec.c
index 58fb55e2bf7ae1546f0051e64d892fb8370008d3..f550194b18ff012bb7a9f6812362b9739ae66f8c 100644 (file)
--- a/gdb/exec.c
+++ b/gdb/exec.c
@@ -1,6 +1,6 @@
 /* Work with executable files, for GDB. 
 
-   Copyright (C) 1988-2003, 2007-2012 Free Software Foundation, Inc.
+   Copyright (C) 1988-2013 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -33,6 +33,7 @@
 #include "arch-utils.h"
 #include "gdbthread.h"
 #include "progspace.h"
+#include "gdb_bfd.h"
 
 #include <fcntl.h>
 #include "readline/readline.h"
@@ -98,17 +99,15 @@ exec_close (void)
   if (exec_bfd)
     {
       bfd *abfd = exec_bfd;
-      char *name = bfd_get_filename (abfd);
 
-      gdb_bfd_close_or_warn (abfd);
-      xfree (name);
+      gdb_bfd_unref (abfd);
 
       /* Removing target sections may close the exec_ops target.
         Clear exec_bfd before doing so to prevent recursion.  */
       exec_bfd = NULL;
       exec_bfd_mtime = 0;
 
-      remove_target_sections (abfd);
+      remove_target_sections (&exec_bfd, abfd);
     }
 }
 
@@ -116,9 +115,8 @@ exec_close (void)
    sections and closes all executable bfds from all program spaces.  */
 
 static void
-exec_close_1 (int quitting)
+exec_close_1 (void)
 {
-  int need_symtab_cleanup = 0;
   struct vmap *vp, *nxt;
 
   using_exec_ops = 0;
@@ -128,17 +126,10 @@ exec_close_1 (int quitting)
       vp = nxt;
       nxt = vp->nxt;
 
-      /* if there is an objfile associated with this bfd,
-         free_objfile() will do proper cleanup of objfile *and* bfd.  */
-
       if (vp->objfile)
-       {
-         free_objfile (vp->objfile);
-         need_symtab_cleanup = 1;
-       }
-      else if (vp->bfd != exec_bfd)
-       /* FIXME-leak: We should be freeing vp->name too, I think.  */
-       gdb_bfd_close_or_warn (vp->bfd);
+       free_objfile (vp->objfile);
+
+      gdb_bfd_unref (vp->bfd);
 
       xfree (vp);
     }
@@ -232,24 +223,21 @@ exec_file_attach (char *filename, int from_tty)
 #endif
       if (scratch_chan < 0)
        perror_with_name (filename);
-      exec_bfd = bfd_fopen (scratch_pathname, gnutarget,
-                           write_files ? FOPEN_RUB : FOPEN_RB,
-                           scratch_chan);
+
+      cleanups = make_cleanup (xfree, scratch_pathname);
+
+      if (write_files)
+       exec_bfd = gdb_bfd_fopen (scratch_pathname, gnutarget,
+                                 FOPEN_RUB, scratch_chan);
+      else
+       exec_bfd = gdb_bfd_open (scratch_pathname, gnutarget, scratch_chan);
 
       if (!exec_bfd)
        {
-         close (scratch_chan);
          error (_("\"%s\": could not open as an executable file: %s"),
                 scratch_pathname, bfd_errmsg (bfd_get_error ()));
        }
 
-      /* At this point, scratch_pathname and exec_bfd->name both point to the
-         same malloc'd string.  However exec_close() will attempt to free it
-         via the exec_bfd->name pointer, so we need to make another copy and
-         leave exec_bfd as the new owner of the original copy.  */
-      scratch_pathname = xstrdup (scratch_pathname);
-      cleanups = make_cleanup (xfree, scratch_pathname);
-
       if (!bfd_check_format_matches (exec_bfd, bfd_object, &matching))
        {
          /* Make sure to close exec_bfd, or else "run" might try to use
@@ -294,7 +282,7 @@ exec_file_attach (char *filename, int from_tty)
       /* Add the executable's sections to the current address spaces'
         list of sections.  This possibly pushes the exec_ops
         target.  */
-      add_target_sections (sections, sections_end);
+      add_target_sections (&exec_bfd, sections, sections_end);
       xfree (sections);
 
       /* Tell display code (if any) about the changed file name.  */
@@ -388,6 +376,7 @@ add_to_section_table (bfd *abfd, struct bfd_section *asect,
   if (!(aflag & SEC_ALLOC))
     return;
 
+  (*table_pp)->key = NULL;
   (*table_pp)->bfd = abfd;
   (*table_pp)->the_bfd_section = asect;
   (*table_pp)->addr = bfd_section_vma (abfd, asect);
@@ -398,11 +387,9 @@ add_to_section_table (bfd *abfd, struct bfd_section *asect,
 int
 resize_section_table (struct target_section_table *table, int num_added)
 {
-  struct target_section *old_value;
   int old_count;
   int new_count;
 
-  old_value = table->sections;
   old_count = table->sections_end - table->sections;
 
   new_count = num_added + old_count;
@@ -448,7 +435,8 @@ build_section_table (struct bfd *some_bfd, struct target_section **start,
    current set of target sections.  */
 
 void
-add_target_sections (struct target_section *sections,
+add_target_sections (void *key,
+                    struct target_section *sections,
                     struct target_section *sections_end)
 {
   int count;
@@ -459,9 +447,13 @@ add_target_sections (struct target_section *sections,
   if (count > 0)
     {
       int space = resize_section_table (table, count);
+      int i;
 
-      memcpy (table->sections + space,
-             sections, count * sizeof (sections[0]));
+      for (i = 0; i < count; ++i)
+       {
+         table->sections[space + i] = sections[i];
+         table->sections[space + i].key = key;
+       }
 
       /* If these are the first file sections we can provide memory
         from, push the file_stratum target.  */
@@ -476,14 +468,14 @@ add_target_sections (struct target_section *sections,
 /* Remove all target sections taken from ABFD.  */
 
 void
-remove_target_sections (bfd *abfd)
+remove_target_sections (void *key, bfd *abfd)
 {
   struct target_section *src, *dest;
   struct target_section_table *table = current_target_sections;
 
   dest = table->sections;
   for (src = table->sections; src < table->sections_end; src++)
-    if (src->bfd != abfd)
+    if (src->key != key || src->bfd != abfd)
       {
        /* Keep this section.  */
        if (dest < src)
@@ -555,6 +547,7 @@ map_vmap (bfd *abfd, bfd *arch)
   memset ((char *) vp, '\0', sizeof (*vp));
   vp->nxt = 0;
   vp->bfd = abfd;
+  gdb_bfd_ref (abfd);
   vp->name = bfd_get_filename (arch ? arch : abfd);
   vp->member = arch ? bfd_get_filename (abfd) : "";
 
@@ -768,7 +761,7 @@ exec_files_info (struct target_ops *t)
 
   if (vmap)
     {
-      int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
+      int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
       struct vmap *vp;
 
       printf_unfiltered (_("\tMapping info for file `%s'.\n"), vmap->name);