1 /* GDB routines for supporting auto-loaded scripts.
3 Copyright (C) 2010 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "gdb_string.h"
22 #include "gdb_regex.h"
24 #include "exceptions.h"
28 #include "progspace.h"
31 #include "python-internal.h"
32 #include "cli/cli-cmds.h"
34 /* NOTE: It's trivial to also support auto-loading normal gdb scripts.
35 There has yet to be a need so it's not implemented. */
37 /* The suffix of per-objfile scripts to auto-load.
38 E.g. When the program loads libfoo.so, look for libfoo-gdb.py. */
39 #define GDBPY_AUTO_FILE_NAME "-gdb.py"
41 /* The section to look for scripts (in file formats that support sections).
42 Each entry in this section is a byte of value 1, and then the nul-terminated
43 name of the script. The script name may include a directory.
44 The leading byte is to allow upward compatible extensions. */
45 #define GDBPY_AUTO_SECTION_NAME ".debug_gdb_scripts"
47 /* For scripts specified in .debug_gdb_scripts, multiple objfiles may load
48 the same script. There's no point in loading the script multiple times,
49 and there can be a lot of objfiles and scripts, so we keep track of scripts
52 struct auto_load_pspace_info
54 /* For each program space we keep track of loaded scripts. */
55 struct htab *loaded_scripts;
58 /* Objects of this type are stored in the loaded script hash table. */
60 struct loaded_script_entry
62 /* Name as provided by the objfile. */
64 /* Full path name or NULL if script wasn't found (or was otherwise
66 const char *full_path;
69 /* This is true if we should auto-load python code when an objfile is opened,
71 static int gdbpy_auto_load = 1;
73 /* Per-program-space data key. */
74 static const struct program_space_data *auto_load_pspace_data;
77 auto_load_pspace_data_cleanup (struct program_space *pspace, void *arg)
79 struct auto_load_pspace_info *info;
81 info = program_space_data (pspace, auto_load_pspace_data);
84 if (info->loaded_scripts)
85 htab_delete (info->loaded_scripts);
90 /* Get the current autoload data. If none is found yet, add it now. This
91 function always returns a valid object. */
93 static struct auto_load_pspace_info *
94 get_auto_load_pspace_data (struct program_space *pspace)
96 struct auto_load_pspace_info *info;
98 info = program_space_data (pspace, auto_load_pspace_data);
101 info = XZALLOC (struct auto_load_pspace_info);
102 set_program_space_data (pspace, auto_load_pspace_data, info);
108 /* Hash function for the loaded script hash. */
111 hash_loaded_script_entry (const void *data)
113 const struct loaded_script_entry *e = data;
114 return htab_hash_string (e->name);
117 /* Equality function for the loaded script hash. */
120 eq_loaded_script_entry (const void *a, const void *b)
122 const struct loaded_script_entry *ea = a;
123 const struct loaded_script_entry *eb = b;
124 return strcmp (ea->name, eb->name) == 0;
127 /* Create the hash table used for loaded scripts.
128 Each entry is hashed by the full path name. */
131 create_loaded_scripts_hash (struct auto_load_pspace_info *pspace_info)
133 /* Choose 31 as the starting size of the hash table, somewhat arbitrarily.
134 Space for each entry is obtained with one malloc so we can free them
137 pspace_info->loaded_scripts = htab_create (31,
138 hash_loaded_script_entry,
139 eq_loaded_script_entry,
143 /* Load scripts specified in OBJFILE.
144 START,END delimit a buffer containing a list of nul-terminated
146 SOURCE_NAME is used in error messages.
148 Scripts are found per normal "source -s" command processing.
149 First the script is looked for in $cwd. If not found there the
150 source search path is used.
152 The section contains a list of path names of files containing
153 python code to load. Each path is null-terminated. */
156 source_section_scripts (struct objfile *objfile, const char *source_name,
157 const char *start, const char *end)
160 struct auto_load_pspace_info *pspace_info;
161 struct loaded_script_entry **slot, entry;
163 pspace_info = get_auto_load_pspace_data (current_program_space);
164 if (pspace_info->loaded_scripts == NULL)
165 create_loaded_scripts_hash (pspace_info);
167 for (p = start; p < end; ++p)
172 int opened, in_hash_table;
176 warning (_("Invalid entry in %s section"), GDBPY_AUTO_SECTION_NAME);
177 /* We could try various heuristics to find the next valid entry,
178 but it's safer to just punt. */
183 while (p < end && *p != '\0')
187 char *buf = alloca (p - file + 1);
188 memcpy (buf, file, p - file);
189 buf[p - file] = '\0';
190 warning (_("Non-null-terminated path in %s: %s"),
197 warning (_("Empty path in %s"), source_name);
201 opened = find_and_open_script (file, 1 /*search_path*/,
202 &stream, &full_path);
204 /* If the file is not found, we still record the file in the hash table,
205 we only want to print an error message once.
206 IWBN if complaints.c were more general-purpose. */
210 entry.full_path = full_path;
212 entry.full_path = NULL;
213 slot = ((struct loaded_script_entry **)
214 htab_find_slot (pspace_info->loaded_scripts,
216 in_hash_table = *slot != NULL;
218 /* If this file is not in the hash table, add it. */
222 *slot = xmalloc (sizeof (**slot)
224 + (opened ? (strlen (full_path) + 1) : 0));
225 p = ((char*) *slot) + sizeof (**slot);
231 strcpy (p, full_path);
232 (*slot)->full_path = p;
235 (*slot)->full_path = NULL;
243 /* We don't throw an error, the program is still debuggable.
244 Check in_hash_table to only print the warning once. */
246 warning (_("%s (referenced in %s): %s\n"),
247 file, GDBPY_AUTO_SECTION_NAME, safe_strerror (errno));
251 /* If this file is not currently loaded, load it. */
253 source_python_script_for_objfile (objfile, stream, file);
257 /* Load scripts specified in section SECTION_NAME of OBJFILE. */
260 auto_load_section_scripts (struct objfile *objfile, const char *section_name)
262 bfd *abfd = objfile->obfd;
263 asection *scripts_sect;
266 struct cleanup *cleanups;
268 scripts_sect = bfd_get_section_by_name (abfd, section_name);
269 if (scripts_sect == NULL)
272 size = bfd_get_section_size (scripts_sect);
275 cleanups = make_cleanup (xfree, p);
277 if (bfd_get_section_contents (abfd, scripts_sect, p, (file_ptr) 0, size))
278 source_section_scripts (objfile, section_name, p, p + size);
280 warning (_("Couldn't read %s section of %s"),
281 section_name, bfd_get_filename (abfd));
283 do_cleanups (cleanups);
286 /* Clear the table of loaded section scripts. */
289 clear_section_scripts (void)
291 struct program_space *pspace = current_program_space;
292 struct auto_load_pspace_info *info;
294 info = program_space_data (pspace, auto_load_pspace_data);
295 if (info != NULL && info->loaded_scripts != NULL)
297 htab_delete (info->loaded_scripts);
298 info->loaded_scripts = NULL;
302 /* Look for the auto-load script associated with OBJFILE and load it. */
305 auto_load_objfile_script (struct objfile *objfile, const char *suffix)
308 char *filename, *debugfile;
311 struct cleanup *cleanups;
313 realname = gdb_realpath (objfile->name);
314 len = strlen (realname);
315 filename = xmalloc (len + strlen (suffix) + 1);
316 memcpy (filename, realname, len);
317 strcpy (filename + len, suffix);
319 cleanups = make_cleanup (xfree, filename);
320 make_cleanup (xfree, realname);
322 input = fopen (filename, "r");
323 debugfile = filename;
325 if (!input && debug_file_directory)
327 /* Also try the same file in the separate debug info directory. */
328 debugfile = xmalloc (strlen (filename)
329 + strlen (debug_file_directory) + 1);
330 strcpy (debugfile, debug_file_directory);
331 /* FILENAME is absolute, so we don't need a "/" here. */
332 strcat (debugfile, filename);
334 make_cleanup (xfree, debugfile);
335 input = fopen (debugfile, "r");
338 if (!input && gdb_datadir)
340 /* Also try the same file in a subdirectory of gdb's data
342 debugfile = xmalloc (strlen (gdb_datadir) + strlen (filename)
343 + strlen ("/auto-load") + 1);
344 strcpy (debugfile, gdb_datadir);
345 strcat (debugfile, "/auto-load");
346 /* FILENAME is absolute, so we don't need a "/" here. */
347 strcat (debugfile, filename);
349 make_cleanup (xfree, debugfile);
350 input = fopen (debugfile, "r");
355 source_python_script_for_objfile (objfile, input, debugfile);
359 do_cleanups (cleanups);
362 /* This is a new_objfile observer callback to auto-load scripts.
364 Two flavors of auto-loaded scripts are supported.
365 1) based on the path to the objfile
366 2) from .debug_gdb_scripts section */
369 auto_load_new_objfile (struct objfile *objfile)
373 /* OBJFILE is NULL when loading a new "main" symbol-file. */
374 clear_section_scripts ();
382 auto_load_objfile_script (objfile, GDBPY_AUTO_FILE_NAME);
383 auto_load_section_scripts (objfile, GDBPY_AUTO_SECTION_NAME);
387 /* Traversal function for htab_traverse.
388 Print the entry if specified in the regex. */
391 maybe_print_section_script (void **slot, void *info)
393 struct loaded_script_entry *entry = *slot;
395 if (re_exec (entry->name))
397 printf_filtered (_("Script name: %s\n"), entry->name);
398 printf_filtered (_(" Full name: %s\n"),
399 entry->full_path ? entry->full_path : _("unknown"));
405 /* "maint print section-scripts" command. */
408 maintenance_print_section_scripts (char *pattern, int from_tty)
410 struct auto_load_pspace_info *pspace_info;
414 if (pattern && *pattern)
416 char *re_err = re_comp (pattern);
419 error (_("Invalid regexp: %s"), re_err);
421 printf_filtered (_("Objfile scripts matching %s:\n"), pattern);
426 printf_filtered (_("Objfile scripts:\n"));
429 pspace_info = get_auto_load_pspace_data (current_program_space);
430 if (pspace_info == NULL || pspace_info->loaded_scripts == NULL)
434 htab_traverse_noresize (pspace_info->loaded_scripts,
435 maybe_print_section_script, NULL);
440 gdbpy_initialize_auto_load (void)
442 auto_load_pspace_data
443 = register_program_space_data_with_cleanup (auto_load_pspace_data_cleanup);
445 observer_attach_new_objfile (auto_load_new_objfile);
447 add_setshow_boolean_cmd ("auto-load", class_maintenance,
448 &gdbpy_auto_load, _("\
449 Enable or disable auto-loading of Python code when an object is opened."), _("\
450 Show whether Python code will be auto-loaded when an object is opened."), _("\
451 Enables or disables auto-loading of Python code when an object is opened."),
456 add_cmd ("section-scripts", class_maintenance, maintenance_print_section_scripts,
457 _("Print dump of auto-loaded section scripts matching REGEXP."),
458 &maintenanceprintlist);