Move .debug_gdb_script processing to auto-load.c.

Simplify handling of auto-loaded objfile scripts.

.debug_gdb_scripts was always intended to handle more than just python,
thus the rightful home for the code that processes it is not in py-foo.c.
This is just a cleanup to move the code to a better place.

This also simplifies the handling of the ${objfile}-${suffix} auto-loaded
scripts.  There's no need for each of the the handlers to do is-safe-to-load
checking, or call maybe_add_script.  Doing it in the caller removes the
duplication.

	* auto-load.h (script_language): New members name, auto_load_enabled.
	Add missing comments on struct members.
	(auto_load_objfile_script): Delete.
	* auto-load.c: #include "cli/cli-cmds.h".
	(auto_load_gdb_scripts_enabled): New function.
	(script_language_gdb): Update, add new members.
	(source_gdb_script_for_objfile): Simplify, auto-load safe-checking
	and call to maybe_add_script moved to caller.
	(auto_load_objfile_script_1): Auto-load safe-checking and
	call to maybe_add_script moved here.
	(auto_load_objfile_script): Make static.  Early exit if support for
	scripting language hasn't been compiled in, or auto-loading has been
	disabled.
	(source_section_scripts): Argument "source_name" renamed to
	"section_name".  All uses updated.  Replace uses of AUTO_SECTION_NAME
	with section_name.  Skip loading script if support for scripting
	language hasn't been compiled in, or auto-loading has been disabled.
	Call language->source_script_for_objfile instead of calling
	source_python_script_for_objfile directly.
	(load_auto_scripts_for_objfile): Update.
	* python/py-auto-load.c: Delete #include "cli/cli-cmds.h".
	(gdbpy_load_auto_script_for_objfile): Delete.
	(auto_load_python_scripts_enabled): New function.
	(script_language_python): Update, add new members.
	(gdbpy_script_language_defn): New function.
	* python/python.h (gdbpy_load_auto_scripts_for_objfile): Delete.
	(gdbpy_script_language_defn): Declare.

	* auto-load.c (AUTO_SECTION_NAME): Moved here and renamed from
	py-auto-load.c, GDBPY_AUTO_SECTION_NAME.
	(source_section_scripts): Moved here from py-auto-load.c.
	(auto_load_section_scripts): Ditto.
	* python/py-auto-load.c (GDBPY_AUTO_SECTION_NAME): Moved to
	auto-load.c, renamed AUTO_SECTION_NAME.
	(source_section_scripts, auto_load_section_scripts): Moved to
	auto-load.c.

1 files changed, 204 insertions, 25 deletions

diff --git a/gdb/auto-load.c b/gdb/auto-load.c
index 2c534c7..02b08be 100644
--- a/gdb/auto-load.c
+++ b/gdb/auto-load.c
@@ -30,6 +30,7 @@
 #include "exceptions.h"
 #include "cli/cli-script.h"
 #include "gdbcmd.h"
+#include "cli/cli-cmds.h"
 #include "cli/cli-decode.h"
 #include "cli/cli-setshow.h"
 #include "gdb_vecs.h"
@@ -40,6 +41,14 @@
 #include "top.h"
 #include "filestuff.h"
 
+/* The section to look in for auto-loaded scripts (in file formats that
+   support sections).
+   Each entry in this section is a record that begins with a leading byte
+   identifying the record type.
+   At the moment we only support one record type: A leading byte of 1,
+   followed by the path of a python script to load.  */
+#define AUTO_SECTION_NAME ".debug_gdb_scripts"
+
 /* The suffix of per-objfile scripts to auto-load as non-Python command files.
    E.g. When the program loads libfoo.so, look for libfoo-gdb.gdb.  */
 #define GDB_AUTO_FILE_NAME "-gdb.gdb"
@@ -79,6 +88,14 @@ show_auto_load_gdb_scripts (struct ui_file *file, int from_tty,
 		    value);
 }
 
+/* Return non-zero if auto-loading gdb scripts is enabled.  */
+
+static int
+auto_load_gdb_scripts_enabled (void)
+{
+  return auto_load_gdb_scripts;
+}
+
 /* 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.
@@ -502,31 +519,20 @@ For more information about this security protection see the\n\
 
 /* Definition of script language for GDB canned sequences of commands.  */
 
-static const struct script_language script_language_gdb
-  = { GDB_AUTO_FILE_NAME, source_gdb_script_for_objfile };
+static const struct script_language script_language_gdb =
+{
+  "gdb",
+  GDB_AUTO_FILE_NAME,
+  auto_load_gdb_scripts_enabled,
+  source_gdb_script_for_objfile
+};
 
 static void
 source_gdb_script_for_objfile (struct objfile *objfile, FILE *file,
 			       const char *filename)
 {
-  int is_safe;
-  struct auto_load_pspace_info *pspace_info;
   volatile struct gdb_exception e;
 
-  is_safe = file_is_auto_load_safe (filename, _("auto-load: Loading canned "
-						"sequences of commands script "
-						"\"%s\" for objfile \"%s\".\n"),
-				    filename, objfile_name (objfile));
-
-  /* Add this script to the hash table too so "info auto-load gdb-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_gdb);
-
-  if (!is_safe)
-    return;
-
   TRY_CATCH (e, RETURN_MASK_ALL)
     {
       script_from_file (file, filename);
@@ -780,14 +786,31 @@ auto_load_objfile_script_1 (struct objfile *objfile, const char *realname,
 
   if (input)
     {
+      int is_safe;
+      struct auto_load_pspace_info *pspace_info;
+
       make_cleanup_fclose (input);
 
+      is_safe
+	= file_is_auto_load_safe (filename,
+				  _("auto-load: Loading %s script \"%s\""
+				    " by extension for objfile \"%s\".\n"),
+				  language->name, filename,
+				  objfile_name (objfile));
+
+      /* Add this script to the hash table too so
+	 "info auto-load ${lang}-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, language);
+
       /* To preserve existing behaviour we don't check for whether the
 	 script was already in the table, and always load it.
 	 It's highly unlikely that we'd ever load it twice,
 	 and these scripts are required to be idempotent under multiple
 	 loads anyway.  */
-      language->source_script_for_objfile (objfile, input, debugfile);
+      if (is_safe)
+	language->source_script_for_objfile (objfile, input, debugfile);
 
       retval = 1;
     }
@@ -801,12 +824,21 @@ auto_load_objfile_script_1 (struct objfile *objfile, const char *realname,
 /* Look for the auto-load script in LANGUAGE associated with OBJFILE and load
    it.  */
 
-void
+static void
 auto_load_objfile_script (struct objfile *objfile,
 			  const struct script_language *language)
 {
-  char *realname = gdb_realpath (objfile_name (objfile));
-  struct cleanup *cleanups = make_cleanup (xfree, realname);
+  char *realname;
+  struct cleanup *cleanups;
+
+  /* Skip this script if support has not been compiled in or
+     auto-loading it has been disabled.  */
+  if (language == NULL
+      || !language->auto_load_enabled ())
+    return;
+
+  realname = gdb_realpath (objfile_name (objfile));
+  cleanups = make_cleanup (xfree, realname);
 
   if (!auto_load_objfile_script_1 (objfile, realname, language))
     {
@@ -831,6 +863,153 @@ auto_load_objfile_script (struct objfile *objfile,
   do_cleanups (cleanups);
 }
 
+/* Load scripts specified in OBJFILE.
+   START,END delimit a buffer containing a list of nul-terminated
+   file names.
+   SECTION_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 script files to load.
+   Each path is null-terminated.  */
+
+static void
+source_section_scripts (struct objfile *objfile, const char *section_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;
+      /* At the moment we only support python scripts in .debug_gdb_scripts,
+	 but that can change.  */
+      const struct script_language *language = gdbpy_script_language_defn ();
+
+      if (*p != 1)
+	{
+	  warning (_("Invalid entry in %s section"), section_name);
+	  /* We could try various heuristics to find the next valid entry,
+	     but it's safer to just punt.  */
+	  break;
+	}
+      file = ++p;
+
+      while (p < end && *p != '\0')
+	++p;
+      if (p == end)
+	{
+	  char *buf = alloca (p - file + 1);
+
+	  memcpy (buf, file, p - file);
+	  buf[p - file] = '\0';
+	  warning (_("Non-null-terminated path in %s: %s"),
+		   section_name, buf);
+	  /* Don't load it.  */
+	  break;
+	}
+      if (p == file)
+	{
+	  warning (_("Empty path in %s"), section_name);
+	  continue;
+	}
+
+      /* Skip this script if support has not been compiled in or
+	 auto-loading it has been disabled.  */
+      if (language == NULL
+	  || !language->auto_load_enabled ())
+	{
+	  /* No message is printed, just skip it.  */
+	  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 %s script "
+					 "\"%s\" from section \"%s\" of "
+					 "objfile \"%s\".\n"),
+				       language->name, full_path, section_name,
+				       objfile_name (objfile)))
+	    opened = 0;
+	}
+      else
+	{
+	  full_path = NULL;
+
+	  /* If one script isn't found it's not uncommon for more to not be
+	     found either.  We don't want to print a 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.
+	     We don't throw an error, the program is still debuggable.
+
+	     IWBN if complaints.c were more general-purpose.  */
+
+	  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 %s-scripts [REGEXP]' to list them."),
+		     section_name, objfile_name (objfile), language->name);
+	}
+
+      in_hash_table = maybe_add_script (pspace_info, opened, file, full_path,
+					language);
+
+      /* If this file is not currently loaded, load it.  */
+      if (opened && !in_hash_table)
+	{
+	  gdb_assert (language->source_script_for_objfile != NULL);
+	  language->source_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_byte *data = NULL;
+
+  scripts_sect = bfd_get_section_by_name (abfd, section_name);
+  if (scripts_sect == NULL)
+    return;
+
+  if (!bfd_get_full_section_contents (abfd, scripts_sect, &data))
+    warning (_("Couldn't read %s section of %s"),
+	     section_name, bfd_get_filename (abfd));
+  else
+    {
+      struct cleanup *cleanups;
+      char *p = (char *) data;
+
+      cleanups = make_cleanup (xfree, p);
+      source_section_scripts (objfile, section_name, p,
+			      p + bfd_get_section_size (scripts_sect));
+      do_cleanups (cleanups);
+    }
+}
+
 /* Load any auto-loaded scripts for OBJFILE.  */
 
 void
@@ -839,10 +1018,10 @@ load_auto_scripts_for_objfile (struct objfile *objfile)
   if (!global_auto_load || (objfile->flags & OBJF_NOT_FILENAME) != 0)
     return;
 
-  if (auto_load_gdb_scripts)
-    auto_load_objfile_script (objfile, &script_language_gdb);
+  auto_load_objfile_script (objfile, &script_language_gdb);
+  auto_load_objfile_script (objfile, gdbpy_script_language_defn ());
 
-  gdbpy_load_auto_scripts_for_objfile (objfile);
+  auto_load_section_scripts (objfile, AUTO_SECTION_NAME);
 }
 
 /* This is a new_objfile observer callback to auto-load scripts.