Merge GDB 7.5.1

gdb/python/py-auto-load.c

 /* GDB routines for supporting auto-loaded scripts.
 
    Copyright (C) 2010-2012 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
    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.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
-#include "filenames.h"
 #include "gdb_string.h"
-#include "gdb_regex.h"
 #include "top.h"
 #include "exceptions.h"
-#include "command.h"
 #include "gdbcmd.h"
-#include "observer.h"
-#include "progspace.h"
 #include "objfiles.h"
 #include "python.h"
 #include "cli/cli-cmds.h"
-
-/* Internal-use flag to enable/disable auto-loading.
-   This is true if we should auto-load python code when an objfile is opened,
-   false otherwise.
-
-   Both auto_load_scripts && gdbpy_global_auto_load must be true to enable
-   auto-loading.
-
-   This flag exists to facilitate deferring auto-loading during start-up
-   until after ./.gdbinit has been read; it may augment the search directories
-   used to find the scripts.  */
-int gdbpy_global_auto_load = 1;
+#include "auto-load.h"
 
 #ifdef HAVE_PYTHON
 
 #include "python-internal.h"
 
-/* NOTE: It's trivial to also support auto-loading normal gdb scripts.
-   There has yet to be a need so it's not implemented.  */
-
-/* The suffix of per-objfile scripts to auto-load.
-   E.g. When the program loads libfoo.so, look for libfoo-gdb.py.  */
-#define GDBPY_AUTO_FILE_NAME "-gdb.py"
-
-/* The section to look for scripts (in file formats that support sections).
+/* The section to look for Python auto-loaded scripts (in file formats that
+   support sections).
    Each entry in this section is a byte of value 1, and then the nul-terminated
    name of the script.  The script name may include a directory.
    The leading byte is to allow upward compatible extensions.  */
 #define GDBPY_AUTO_SECTION_NAME ".debug_gdb_scripts"
 
-/* For scripts specified in .debug_gdb_scripts, multiple objfiles may load
-   the same script.  There's no point in loading the script multiple times,
-   and there can be a lot of objfiles and scripts, so we keep track of scripts
-   loaded this way.  */
+/* User-settable option to enable/disable auto-loading of Python scripts:
+   set auto-load python-scripts on|off
+   This is true if we should auto-load associated Python scripts when an
+   objfile is opened, false otherwise.  */
+static int auto_load_python_scripts = 1;
 
-struct auto_load_pspace_info
-{
-  /* For each program space we keep track of loaded scripts.  */
-  struct htab *loaded_scripts;
+static void gdbpy_load_auto_script_for_objfile (struct objfile *objfile,
+                                                FILE *file,
+                                                const char *filename);
 
-  /* Non-zero if we've issued the warning about an auto-load script not being
-     found.  We only want to issue this warning once.  */
-  int script_not_found_warning_printed;
-};
-
-/* Objects of this type are stored in the loaded script hash table.  */
-
-struct loaded_script
-{
-  /* Name as provided by the objfile.  */
-  const char *name;
-  /* Full path name or NULL if script wasn't found (or was otherwise
-     inaccessible).  */
-  const char *full_path;
-};
-
-/* User-settable option to enable/disable auto-loading:
-   set auto-load-scripts on|off
-   This is true if we should auto-load associated scripts when an objfile
-   is opened, false otherwise.
-   At the moment, this only affects python scripts, but there's no reason
-   one couldn't also have other kinds of auto-loaded scripts, and there's
-   no reason to have them each controlled by a separate flag.
-   So we elide "python" from the name here and in the option.
-   The fact that it lives here is just an implementation detail.  */
-static int auto_load_scripts = 1;
-
-/* Per-program-space data key.  */
-static const struct program_space_data *auto_load_pspace_data;
+/* "show" command for the auto_load_python_scripts configuration variable.  */
 
 static void
-auto_load_pspace_data_cleanup (struct program_space *pspace, void *arg)
+show_auto_load_python_scripts (struct ui_file *file, int from_tty,
+                               struct cmd_list_element *c, const char *value)
 {
-  struct auto_load_pspace_info *info;
-
-  info = program_space_data (pspace, auto_load_pspace_data);
-  if (info != NULL)
-    {
-      if (info->loaded_scripts)
-        htab_delete (info->loaded_scripts);
-      xfree (info);
-    }
+  fprintf_filtered (file, _("Auto-loading of Python scripts is %s.\n"), value);
 }
 
-/* Get the current autoload data.  If none is found yet, add it now.  This
-   function always returns a valid object.  */
+/* Definition of script language for Python scripts.  */
 
-static struct auto_load_pspace_info *
-get_auto_load_pspace_data (struct program_space *pspace)
-{
-  struct auto_load_pspace_info *info;
+static const struct script_language script_language_python
+  = { GDBPY_AUTO_FILE_NAME, gdbpy_load_auto_script_for_objfile };
 
-  info = program_space_data (pspace, auto_load_pspace_data);
-  if (info == NULL)
-    {
-      info = XZALLOC (struct auto_load_pspace_info);
-      set_program_space_data (pspace, auto_load_pspace_data, info);
-    }
-
-  return info;
-}
-
-/* Hash function for the loaded script hash.  */
-
-static hashval_t
-hash_loaded_script_entry (const void *data)
-{
-  const struct loaded_script *e = data;
-
-  return htab_hash_string (e->name);
-}
-
-/* Equality function for the loaded script hash.  */
-
-static int
-eq_loaded_script_entry (const void *a, const void *b)
-{
-  const struct loaded_script *ea = a;
-  const struct loaded_script *eb = b;
-
-  return strcmp (ea->name, eb->name) == 0;
-}
-
-/* Initialize the table to track loaded scripts.
-   Each entry is hashed by the full path name.  */
+/* Wrapper of source_python_script_for_objfile for script_language_python.  */
 
 static void
-init_loaded_scripts_info (struct auto_load_pspace_info *pspace_info)
+gdbpy_load_auto_script_for_objfile (struct objfile *objfile, FILE *file,
+                                    const char *filename)
 {
-  /* Choose 31 as the starting size of the hash table, somewhat arbitrarily.
-     Space for each entry is obtained with one malloc so we can free them
-     easily.  */
+  int is_safe;
+  struct auto_load_pspace_info *pspace_info;
 
-  pspace_info->loaded_scripts = htab_create (31,
-                                             hash_loaded_script_entry,
-                                             eq_loaded_script_entry,
-                                             xfree);
+  is_safe = file_is_auto_load_safe (filename,
+                                    _("auto-load: Loading Python script \"%s\" "
+                                      "by extension for objfile \"%s\".\n"),
+                                    filename, objfile->name);
 
-  pspace_info->script_not_found_warning_printed = FALSE;
-}
+  /* Add this script to the hash table too so "info auto-load python-scripts"
+     can print it.  */
+  pspace_info = get_auto_load_pspace_data_for_loading (current_program_space);
+  maybe_add_script (pspace_info, is_safe, filename, filename,
+                    &script_language_python);
 
-/* Wrapper on get_auto_load_pspace_data to also allocate the hash table
-   for loading scripts.  */
-
-static struct auto_load_pspace_info *
-get_auto_load_pspace_data_for_loading (struct program_space *pspace)
-{
-  struct auto_load_pspace_info *info;
-
-  info = get_auto_load_pspace_data (pspace);
-  if (info->loaded_scripts == NULL)
-    init_loaded_scripts_info (info);
-
-  return info;
-}
-
-/* Add script NAME to hash table HTAB.
-   FULL_PATH is NULL if the script wasn't found.
-   The result is true if the script was already in the hash table.  */
-
-static int
-maybe_add_script (struct htab *htab, const char *name, const char *full_path)
-{
-  struct loaded_script **slot, entry;
-  int in_hash_table;
-
-  entry.name = name;
-  entry.full_path = full_path;
-  slot = (struct loaded_script **) htab_find_slot (htab, &entry, INSERT);
-  in_hash_table = *slot != NULL;
-
-  /* If this script is not in the hash table, add it.  */
-
-  if (! in_hash_table)
-    {
-      char *p;
-
-      /* Allocate all space in one chunk so it's easier to free.  */
-      *slot = xmalloc (sizeof (**slot)
-                       + strlen (name) + 1
-                       + (full_path != NULL ? (strlen (full_path) + 1) : 0));
-      p = ((char*) *slot) + sizeof (**slot);
-      strcpy (p, name);
-      (*slot)->name = p;
-      if (full_path != NULL)
-        {
-          p += strlen (p) + 1;
-          strcpy (p, full_path);
-          (*slot)->full_path = p;
-        }
-      else
-        (*slot)->full_path = NULL;
-    }
-
-  return in_hash_table;
+  if (is_safe)
+    source_python_script_for_objfile (objfile, file, filename);
 }
 
 /* Load scripts specified in OBJFILE.
    START,END delimit a buffer containing a list of nul-terminated
    file names.
    SOURCE_NAME is used in error messages.
 
    Scripts are found per normal "source -s" command processing.
    First the script is looked for in $cwd.  If not found there the
    source search path is used.
 
    The section contains a list of path names of files containing
    python code to load.  Each path is null-terminated.  */
 
 static void
 source_section_scripts (struct objfile *objfile, const char *source_name,
                         const char *start, const char *end)
 {
   const char *p;
   struct auto_load_pspace_info *pspace_info;
 
   pspace_info = get_auto_load_pspace_data_for_loading (current_program_space);
 
   for (p = start; p < end; ++p)
     {
       const char *file;
       FILE *stream;
       char *full_path;
       int opened, in_hash_table;
+      struct cleanup *back_to;
 
       if (*p != 1)
         {
           warning (_("Invalid entry in %s section"), GDBPY_AUTO_SECTION_NAME);
           /* We could try various heuristics to find the next valid entry,
              but it's safer to just punt.  */
           break;
         }
       file = ++p;
 
@@ skipping 12 matching lines @@
         }
       if (p == file)
         {
           warning (_("Empty path in %s"), source_name);
           continue;
         }
 
       opened = find_and_open_script (file, 1 /*search_path*/,
                                      &stream, &full_path);
 
+      back_to = make_cleanup (null_cleanup, NULL);
+      if (opened)
+        {
+          make_cleanup_fclose (stream);
+          make_cleanup (xfree, full_path);
+
+          if (!file_is_auto_load_safe (full_path,
+                                       _("auto-load: Loading Python script "
+                                         "\"%s\" from section \"%s\" of "
+                                         "objfile \"%s\".\n"),
+                                       full_path, GDBPY_AUTO_SECTION_NAME,
+                                       objfile->name))
+            opened = 0;
+        }
+      else
+        {
+          full_path = NULL;
+
+          /* We don't throw an error, the program is still debuggable.  */
+          if (script_not_found_warning_print (pspace_info))
+            warning (_("Missing auto-load scripts referenced in section %s\n\
+of file %s\n\
+Use `info auto-load python [REGEXP]' to list them."),
+                     GDBPY_AUTO_SECTION_NAME, objfile->name);
+        }
+
       /* If one script isn't found it's not uncommon for more to not be
          found either.  We don't want to print an error message for each
          script, too much noise.  Instead, we print the warning once and tell
          the user how to find the list of scripts that weren't loaded.
 
          IWBN if complaints.c were more general-purpose.  */
 
-      in_hash_table = maybe_add_script (pspace_info->loaded_scripts, file,
-                                        opened ? full_path : NULL);
+      in_hash_table = maybe_add_script (pspace_info, opened, file, full_path,
+                                        &script_language_python);
 
-      if (! opened)
-        {
-          /* We don't throw an error, the program is still debuggable.  */
-          if (! pspace_info->script_not_found_warning_printed)
-            {
-              warning (_("Missing auto-load scripts referenced in section %s\n\
-of file %s\n\
-Use `info auto-load-scripts [REGEXP]' to list them."),
-                       GDBPY_AUTO_SECTION_NAME, objfile->name);
-              pspace_info->script_not_found_warning_printed = TRUE;
-            }
-        }
-      else
-        {
-          /* If this file is not currently loaded, load it.  */
-          if (! in_hash_table)
-            source_python_script_for_objfile (objfile, full_path);
-          fclose (stream);
-          xfree (full_path);
-        }
+      /* If this file is not currently loaded, load it.  */
+      if (opened && !in_hash_table)
+        source_python_script_for_objfile (objfile, stream, full_path);
+
+      do_cleanups (back_to);
     }
 }
 
 /* Load scripts specified in section SECTION_NAME of OBJFILE.  */
 
 static void
 auto_load_section_scripts (struct objfile *objfile, const char *section_name)
 {
   bfd *abfd = objfile->obfd;
   asection *scripts_sect;
   bfd_size_type size;
   char *p;
   struct cleanup *cleanups;
 
   scripts_sect = bfd_get_section_by_name (abfd, section_name);
   if (scripts_sect == NULL)
     return;
 
   size = bfd_get_section_size (scripts_sect);
   p = xmalloc (size);
   
   cleanups = make_cleanup (xfree, p);
 
   if (bfd_get_section_contents (abfd, scripts_sect, p, (file_ptr) 0, size))
     source_section_scripts (objfile, section_name, p, p + size);
   else
     warning (_("Couldn't read %s section of %s"),
              section_name, bfd_get_filename (abfd));