1 /* GDB routines for supporting auto-loaded scripts.
3 Copyright (C) 2010, 2011 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 "cli/cli-cmds.h"
33 /* Internal-use flag to enable/disable auto-loading.
34 This is true if we should auto-load python code when an objfile is opened,
37 Both auto_load_scripts && gdbpy_global_auto_load must be true to enable
40 This flag exists to facilitate deferring auto-loading during start-up
41 until after ./.gdbinit has been read; it may augment the search directories
42 used to find the scripts. */
43 int gdbpy_global_auto_load
= 1;
47 #include "python-internal.h"
49 /* NOTE: It's trivial to also support auto-loading normal gdb scripts.
50 There has yet to be a need so it's not implemented. */
52 /* The suffix of per-objfile scripts to auto-load.
53 E.g. When the program loads libfoo.so, look for libfoo-gdb.py. */
54 #define GDBPY_AUTO_FILE_NAME "-gdb.py"
56 /* The section to look for scripts (in file formats that support sections).
57 Each entry in this section is a byte of value 1, and then the nul-terminated
58 name of the script. The script name may include a directory.
59 The leading byte is to allow upward compatible extensions. */
60 #define GDBPY_AUTO_SECTION_NAME ".debug_gdb_scripts"
62 /* For scripts specified in .debug_gdb_scripts, multiple objfiles may load
63 the same script. There's no point in loading the script multiple times,
64 and there can be a lot of objfiles and scripts, so we keep track of scripts
67 struct auto_load_pspace_info
69 /* For each program space we keep track of loaded scripts. */
70 struct htab
*loaded_scripts
;
73 /* Objects of this type are stored in the loaded script hash table. */
75 struct loaded_script_entry
77 /* Name as provided by the objfile. */
79 /* Full path name or NULL if script wasn't found (or was otherwise
81 const char *full_path
;
84 /* User-settable option to enable/disable auto-loading:
85 set auto-load-scripts on|off
86 This is true if we should auto-load associated scripts when an objfile
87 is opened, false otherwise.
88 At the moment, this only affects python scripts, but there's no reason
89 one couldn't also have other kinds of auto-loaded scripts, and there's
90 no reason to have them each controlled by a separate flag.
91 So we elide "python" from the name here and in the option.
92 The fact that it lives here is just an implementation detail. */
93 static int auto_load_scripts
= 1;
95 /* Per-program-space data key. */
96 static const struct program_space_data
*auto_load_pspace_data
;
99 auto_load_pspace_data_cleanup (struct program_space
*pspace
, void *arg
)
101 struct auto_load_pspace_info
*info
;
103 info
= program_space_data (pspace
, auto_load_pspace_data
);
106 if (info
->loaded_scripts
)
107 htab_delete (info
->loaded_scripts
);
112 /* Get the current autoload data. If none is found yet, add it now. This
113 function always returns a valid object. */
115 static struct auto_load_pspace_info
*
116 get_auto_load_pspace_data (struct program_space
*pspace
)
118 struct auto_load_pspace_info
*info
;
120 info
= program_space_data (pspace
, auto_load_pspace_data
);
123 info
= XZALLOC (struct auto_load_pspace_info
);
124 set_program_space_data (pspace
, auto_load_pspace_data
, info
);
130 /* Hash function for the loaded script hash. */
133 hash_loaded_script_entry (const void *data
)
135 const struct loaded_script_entry
*e
= data
;
137 return htab_hash_string (e
->name
);
140 /* Equality function for the loaded script hash. */
143 eq_loaded_script_entry (const void *a
, const void *b
)
145 const struct loaded_script_entry
*ea
= a
;
146 const struct loaded_script_entry
*eb
= b
;
148 return strcmp (ea
->name
, eb
->name
) == 0;
151 /* Create the hash table used for loaded scripts.
152 Each entry is hashed by the full path name. */
155 create_loaded_scripts_hash (struct auto_load_pspace_info
*pspace_info
)
157 /* Choose 31 as the starting size of the hash table, somewhat arbitrarily.
158 Space for each entry is obtained with one malloc so we can free them
161 pspace_info
->loaded_scripts
= htab_create (31,
162 hash_loaded_script_entry
,
163 eq_loaded_script_entry
,
167 /* Load scripts specified in OBJFILE.
168 START,END delimit a buffer containing a list of nul-terminated
170 SOURCE_NAME is used in error messages.
172 Scripts are found per normal "source -s" command processing.
173 First the script is looked for in $cwd. If not found there the
174 source search path is used.
176 The section contains a list of path names of files containing
177 python code to load. Each path is null-terminated. */
180 source_section_scripts (struct objfile
*objfile
, const char *source_name
,
181 const char *start
, const char *end
)
184 struct auto_load_pspace_info
*pspace_info
;
185 struct loaded_script_entry
**slot
, entry
;
187 pspace_info
= get_auto_load_pspace_data (current_program_space
);
188 if (pspace_info
->loaded_scripts
== NULL
)
189 create_loaded_scripts_hash (pspace_info
);
191 for (p
= start
; p
< end
; ++p
)
196 int opened
, in_hash_table
;
200 warning (_("Invalid entry in %s section"), GDBPY_AUTO_SECTION_NAME
);
201 /* We could try various heuristics to find the next valid entry,
202 but it's safer to just punt. */
207 while (p
< end
&& *p
!= '\0')
211 char *buf
= alloca (p
- file
+ 1);
213 memcpy (buf
, file
, p
- file
);
214 buf
[p
- file
] = '\0';
215 warning (_("Non-null-terminated path in %s: %s"),
222 warning (_("Empty path in %s"), source_name
);
226 opened
= find_and_open_script (file
, 1 /*search_path*/,
227 &stream
, &full_path
);
229 /* If the file is not found, we still record the file in the hash table,
230 we only want to print an error message once.
231 IWBN if complaints.c were more general-purpose. */
235 entry
.full_path
= full_path
;
237 entry
.full_path
= NULL
;
238 slot
= ((struct loaded_script_entry
**)
239 htab_find_slot (pspace_info
->loaded_scripts
,
241 in_hash_table
= *slot
!= NULL
;
243 /* If this file is not in the hash table, add it. */
248 *slot
= xmalloc (sizeof (**slot
)
250 + (opened
? (strlen (full_path
) + 1) : 0));
251 p
= ((char*) *slot
) + sizeof (**slot
);
257 strcpy (p
, full_path
);
258 (*slot
)->full_path
= p
;
261 (*slot
)->full_path
= NULL
;
269 /* We don't throw an error, the program is still debuggable.
270 Check in_hash_table to only print the warning once. */
272 warning (_("%s (referenced in %s): %s"),
273 file
, GDBPY_AUTO_SECTION_NAME
, safe_strerror (errno
));
277 /* If this file is not currently loaded, load it. */
279 source_python_script_for_objfile (objfile
, stream
, file
);
283 /* Load scripts specified in section SECTION_NAME of OBJFILE. */
286 auto_load_section_scripts (struct objfile
*objfile
, const char *section_name
)
288 bfd
*abfd
= objfile
->obfd
;
289 asection
*scripts_sect
;
292 struct cleanup
*cleanups
;
294 scripts_sect
= bfd_get_section_by_name (abfd
, section_name
);
295 if (scripts_sect
== NULL
)
298 size
= bfd_get_section_size (scripts_sect
);
301 cleanups
= make_cleanup (xfree
, p
);
303 if (bfd_get_section_contents (abfd
, scripts_sect
, p
, (file_ptr
) 0, size
))
304 source_section_scripts (objfile
, section_name
, p
, p
+ size
);
306 warning (_("Couldn't read %s section of %s"),
307 section_name
, bfd_get_filename (abfd
));
309 do_cleanups (cleanups
);
312 /* Clear the table of loaded section scripts. */
315 clear_section_scripts (void)
317 struct program_space
*pspace
= current_program_space
;
318 struct auto_load_pspace_info
*info
;
320 info
= program_space_data (pspace
, auto_load_pspace_data
);
321 if (info
!= NULL
&& info
->loaded_scripts
!= NULL
)
323 htab_delete (info
->loaded_scripts
);
324 info
->loaded_scripts
= NULL
;
328 /* Look for the auto-load script associated with OBJFILE and load it. */
331 auto_load_objfile_script (struct objfile
*objfile
, const char *suffix
)
334 char *filename
, *debugfile
;
337 struct cleanup
*cleanups
;
339 realname
= gdb_realpath (objfile
->name
);
340 len
= strlen (realname
);
341 filename
= xmalloc (len
+ strlen (suffix
) + 1);
342 memcpy (filename
, realname
, len
);
343 strcpy (filename
+ len
, suffix
);
345 cleanups
= make_cleanup (xfree
, filename
);
346 make_cleanup (xfree
, realname
);
348 input
= fopen (filename
, "r");
349 debugfile
= filename
;
351 if (!input
&& debug_file_directory
)
353 /* Also try the same file in the separate debug info directory. */
354 debugfile
= xmalloc (strlen (filename
)
355 + strlen (debug_file_directory
) + 1);
356 strcpy (debugfile
, debug_file_directory
);
357 /* FILENAME is absolute, so we don't need a "/" here. */
358 strcat (debugfile
, filename
);
360 make_cleanup (xfree
, debugfile
);
361 input
= fopen (debugfile
, "r");
364 if (!input
&& gdb_datadir
)
366 /* Also try the same file in a subdirectory of gdb's data
368 debugfile
= xmalloc (strlen (gdb_datadir
) + strlen (filename
)
369 + strlen ("/auto-load") + 1);
370 strcpy (debugfile
, gdb_datadir
);
371 strcat (debugfile
, "/auto-load");
372 /* FILENAME is absolute, so we don't need a "/" here. */
373 strcat (debugfile
, filename
);
375 make_cleanup (xfree
, debugfile
);
376 input
= fopen (debugfile
, "r");
381 source_python_script_for_objfile (objfile
, input
, debugfile
);
385 do_cleanups (cleanups
);
388 /* This is a new_objfile observer callback to auto-load scripts.
390 Two flavors of auto-loaded scripts are supported.
391 1) based on the path to the objfile
392 2) from .debug_gdb_scripts section */
395 auto_load_new_objfile (struct objfile
*objfile
)
399 /* OBJFILE is NULL when loading a new "main" symbol-file. */
400 clear_section_scripts ();
404 load_auto_scripts_for_objfile (objfile
);
407 /* Load any auto-loaded scripts for OBJFILE. */
410 load_auto_scripts_for_objfile (struct objfile
*objfile
)
412 if (auto_load_scripts
&& gdbpy_global_auto_load
)
414 auto_load_objfile_script (objfile
, GDBPY_AUTO_FILE_NAME
);
415 auto_load_section_scripts (objfile
, GDBPY_AUTO_SECTION_NAME
);
419 /* Traversal function for htab_traverse.
420 Print the entry if specified in the regex. */
423 maybe_print_section_script (void **slot
, void *info
)
425 struct loaded_script_entry
*entry
= *slot
;
427 if (re_exec (entry
->name
))
429 printf_filtered (_("Script name: %s\n"), entry
->name
);
430 printf_filtered (_(" Full name: %s\n"),
431 entry
->full_path
? entry
->full_path
: _("unknown"));
437 /* "maint print section-scripts" command. */
440 maintenance_print_section_scripts (char *pattern
, int from_tty
)
442 struct auto_load_pspace_info
*pspace_info
;
446 if (pattern
&& *pattern
)
448 char *re_err
= re_comp (pattern
);
451 error (_("Invalid regexp: %s"), re_err
);
453 printf_filtered (_("Objfile scripts matching %s:\n"), pattern
);
458 printf_filtered (_("Objfile scripts:\n"));
461 pspace_info
= get_auto_load_pspace_data (current_program_space
);
462 if (pspace_info
== NULL
|| pspace_info
->loaded_scripts
== NULL
)
466 htab_traverse_noresize (pspace_info
->loaded_scripts
,
467 maybe_print_section_script
, NULL
);
472 gdbpy_initialize_auto_load (void)
474 auto_load_pspace_data
475 = register_program_space_data_with_cleanup (auto_load_pspace_data_cleanup
);
477 observer_attach_new_objfile (auto_load_new_objfile
);
479 add_setshow_boolean_cmd ("auto-load-scripts", class_support
,
480 &auto_load_scripts
, _("\
481 Set the debugger's behaviour regarding auto-loaded scripts."), _("\
482 Show the debugger's behaviour regarding auto-loaded scripts."), _("\
483 If enabled, auto-loaded scripts are loaded when the debugger reads\n\
484 an executable or shared library."),
489 add_cmd ("section-scripts", class_maintenance
,
490 maintenance_print_section_scripts
,
491 _("Print dump of auto-loaded section scripts matching REGEXP."),
492 &maintenanceprintlist
);
495 #else /* ! HAVE_PYTHON */
498 load_auto_scripts_for_objfile (struct objfile
*objfile
)
502 #endif /* ! HAVE_PYTHON */