Commit | Line | Data |
---|---|---|
8a1ea21f DE |
1 | /* GDB routines for supporting auto-loaded scripts. |
2 | ||
7b6bb8da | 3 | Copyright (C) 2010, 2011 Free Software Foundation, Inc. |
8a1ea21f DE |
4 | |
5 | This file is part of GDB. | |
6 | ||
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. | |
11 | ||
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. | |
16 | ||
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/>. */ | |
19 | ||
20 | #include "defs.h" | |
21 | #include "gdb_string.h" | |
22 | #include "gdb_regex.h" | |
23 | #include "top.h" | |
24 | #include "exceptions.h" | |
25 | #include "command.h" | |
26 | #include "gdbcmd.h" | |
27 | #include "observer.h" | |
28 | #include "progspace.h" | |
29 | #include "objfiles.h" | |
30 | #include "python.h" | |
8a1ea21f DE |
31 | #include "cli/cli-cmds.h" |
32 | ||
88a1906b DE |
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, | |
35 | false otherwise. | |
36 | ||
a86caf66 | 37 | Both auto_load_scripts && gdbpy_global_auto_load must be true to enable |
88a1906b DE |
38 | auto-loading. |
39 | ||
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; | |
44 | ||
45 | #ifdef HAVE_PYTHON | |
46 | ||
47 | #include "python-internal.h" | |
48 | ||
8a1ea21f DE |
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. */ | |
51 | ||
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" | |
55 | ||
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" | |
61 | ||
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 | |
65 | loaded this way. */ | |
66 | ||
67 | struct auto_load_pspace_info | |
68 | { | |
69 | /* For each program space we keep track of loaded scripts. */ | |
70 | struct htab *loaded_scripts; | |
71 | }; | |
72 | ||
73 | /* Objects of this type are stored in the loaded script hash table. */ | |
74 | ||
75 | struct loaded_script_entry | |
76 | { | |
77 | /* Name as provided by the objfile. */ | |
78 | const char *name; | |
79 | /* Full path name or NULL if script wasn't found (or was otherwise | |
80 | inaccessible). */ | |
81 | const char *full_path; | |
82 | }; | |
83 | ||
88a1906b | 84 | /* User-settable option to enable/disable auto-loading: |
a86caf66 DE |
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; | |
8a1ea21f DE |
94 | |
95 | /* Per-program-space data key. */ | |
96 | static const struct program_space_data *auto_load_pspace_data; | |
97 | ||
98 | static void | |
99 | auto_load_pspace_data_cleanup (struct program_space *pspace, void *arg) | |
100 | { | |
101 | struct auto_load_pspace_info *info; | |
102 | ||
103 | info = program_space_data (pspace, auto_load_pspace_data); | |
104 | if (info != NULL) | |
105 | { | |
106 | if (info->loaded_scripts) | |
107 | htab_delete (info->loaded_scripts); | |
108 | xfree (info); | |
109 | } | |
110 | } | |
111 | ||
112 | /* Get the current autoload data. If none is found yet, add it now. This | |
113 | function always returns a valid object. */ | |
114 | ||
115 | static struct auto_load_pspace_info * | |
116 | get_auto_load_pspace_data (struct program_space *pspace) | |
117 | { | |
118 | struct auto_load_pspace_info *info; | |
119 | ||
120 | info = program_space_data (pspace, auto_load_pspace_data); | |
121 | if (info == NULL) | |
122 | { | |
123 | info = XZALLOC (struct auto_load_pspace_info); | |
124 | set_program_space_data (pspace, auto_load_pspace_data, info); | |
125 | } | |
126 | ||
127 | return info; | |
128 | } | |
129 | ||
130 | /* Hash function for the loaded script hash. */ | |
131 | ||
132 | static hashval_t | |
133 | hash_loaded_script_entry (const void *data) | |
134 | { | |
135 | const struct loaded_script_entry *e = data; | |
d59b6f6c | 136 | |
8a1ea21f DE |
137 | return htab_hash_string (e->name); |
138 | } | |
139 | ||
140 | /* Equality function for the loaded script hash. */ | |
141 | ||
142 | static int | |
143 | eq_loaded_script_entry (const void *a, const void *b) | |
144 | { | |
145 | const struct loaded_script_entry *ea = a; | |
146 | const struct loaded_script_entry *eb = b; | |
d59b6f6c | 147 | |
8a1ea21f DE |
148 | return strcmp (ea->name, eb->name) == 0; |
149 | } | |
150 | ||
151 | /* Create the hash table used for loaded scripts. | |
152 | Each entry is hashed by the full path name. */ | |
153 | ||
154 | static void | |
155 | create_loaded_scripts_hash (struct auto_load_pspace_info *pspace_info) | |
156 | { | |
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 | |
159 | easily. */ | |
160 | ||
161 | pspace_info->loaded_scripts = htab_create (31, | |
162 | hash_loaded_script_entry, | |
163 | eq_loaded_script_entry, | |
164 | xfree); | |
165 | } | |
166 | ||
167 | /* Load scripts specified in OBJFILE. | |
168 | START,END delimit a buffer containing a list of nul-terminated | |
169 | file names. | |
170 | SOURCE_NAME is used in error messages. | |
171 | ||
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. | |
175 | ||
176 | The section contains a list of path names of files containing | |
177 | python code to load. Each path is null-terminated. */ | |
178 | ||
179 | static void | |
180 | source_section_scripts (struct objfile *objfile, const char *source_name, | |
181 | const char *start, const char *end) | |
182 | { | |
183 | const char *p; | |
184 | struct auto_load_pspace_info *pspace_info; | |
185 | struct loaded_script_entry **slot, entry; | |
186 | ||
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); | |
190 | ||
191 | for (p = start; p < end; ++p) | |
192 | { | |
193 | const char *file; | |
194 | FILE *stream; | |
195 | char *full_path; | |
196 | int opened, in_hash_table; | |
197 | ||
198 | if (*p != 1) | |
199 | { | |
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. */ | |
203 | break; | |
204 | } | |
205 | file = ++p; | |
206 | ||
207 | while (p < end && *p != '\0') | |
208 | ++p; | |
209 | if (p == end) | |
210 | { | |
211 | char *buf = alloca (p - file + 1); | |
d59b6f6c | 212 | |
8a1ea21f DE |
213 | memcpy (buf, file, p - file); |
214 | buf[p - file] = '\0'; | |
215 | warning (_("Non-null-terminated path in %s: %s"), | |
216 | source_name, buf); | |
217 | /* Don't load it. */ | |
218 | break; | |
219 | } | |
220 | if (p == file) | |
221 | { | |
222 | warning (_("Empty path in %s"), source_name); | |
223 | continue; | |
224 | } | |
225 | ||
226 | opened = find_and_open_script (file, 1 /*search_path*/, | |
227 | &stream, &full_path); | |
228 | ||
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. */ | |
232 | ||
233 | entry.name = file; | |
234 | if (opened) | |
235 | entry.full_path = full_path; | |
236 | else | |
237 | entry.full_path = NULL; | |
238 | slot = ((struct loaded_script_entry **) | |
239 | htab_find_slot (pspace_info->loaded_scripts, | |
240 | &entry, INSERT)); | |
241 | in_hash_table = *slot != NULL; | |
242 | ||
243 | /* If this file is not in the hash table, add it. */ | |
244 | if (! in_hash_table) | |
245 | { | |
246 | char *p; | |
d59b6f6c | 247 | |
8a1ea21f DE |
248 | *slot = xmalloc (sizeof (**slot) |
249 | + strlen (file) + 1 | |
250 | + (opened ? (strlen (full_path) + 1) : 0)); | |
251 | p = ((char*) *slot) + sizeof (**slot); | |
252 | strcpy (p, file); | |
253 | (*slot)->name = p; | |
254 | if (opened) | |
255 | { | |
256 | p += strlen (p) + 1; | |
257 | strcpy (p, full_path); | |
258 | (*slot)->full_path = p; | |
259 | } | |
260 | else | |
261 | (*slot)->full_path = NULL; | |
262 | } | |
263 | ||
264 | if (opened) | |
265 | free (full_path); | |
266 | ||
267 | if (! opened) | |
268 | { | |
269 | /* We don't throw an error, the program is still debuggable. | |
270 | Check in_hash_table to only print the warning once. */ | |
271 | if (! in_hash_table) | |
e78f4312 | 272 | warning (_("%s (referenced in %s): %s"), |
8a1ea21f DE |
273 | file, GDBPY_AUTO_SECTION_NAME, safe_strerror (errno)); |
274 | continue; | |
275 | } | |
276 | ||
277 | /* If this file is not currently loaded, load it. */ | |
278 | if (! in_hash_table) | |
279 | source_python_script_for_objfile (objfile, stream, file); | |
280 | } | |
281 | } | |
282 | ||
283 | /* Load scripts specified in section SECTION_NAME of OBJFILE. */ | |
284 | ||
285 | static void | |
286 | auto_load_section_scripts (struct objfile *objfile, const char *section_name) | |
287 | { | |
288 | bfd *abfd = objfile->obfd; | |
289 | asection *scripts_sect; | |
290 | bfd_size_type size; | |
291 | char *p; | |
292 | struct cleanup *cleanups; | |
293 | ||
294 | scripts_sect = bfd_get_section_by_name (abfd, section_name); | |
295 | if (scripts_sect == NULL) | |
296 | return; | |
297 | ||
298 | size = bfd_get_section_size (scripts_sect); | |
299 | p = xmalloc (size); | |
300 | ||
301 | cleanups = make_cleanup (xfree, p); | |
302 | ||
303 | if (bfd_get_section_contents (abfd, scripts_sect, p, (file_ptr) 0, size)) | |
304 | source_section_scripts (objfile, section_name, p, p + size); | |
305 | else | |
306 | warning (_("Couldn't read %s section of %s"), | |
307 | section_name, bfd_get_filename (abfd)); | |
308 | ||
309 | do_cleanups (cleanups); | |
310 | } | |
311 | ||
312 | /* Clear the table of loaded section scripts. */ | |
313 | ||
314 | static void | |
315 | clear_section_scripts (void) | |
316 | { | |
317 | struct program_space *pspace = current_program_space; | |
318 | struct auto_load_pspace_info *info; | |
319 | ||
320 | info = program_space_data (pspace, auto_load_pspace_data); | |
321 | if (info != NULL && info->loaded_scripts != NULL) | |
322 | { | |
323 | htab_delete (info->loaded_scripts); | |
324 | info->loaded_scripts = NULL; | |
325 | } | |
326 | } | |
327 | ||
328 | /* Look for the auto-load script associated with OBJFILE and load it. */ | |
329 | ||
330 | static void | |
331 | auto_load_objfile_script (struct objfile *objfile, const char *suffix) | |
332 | { | |
333 | char *realname; | |
334 | char *filename, *debugfile; | |
335 | int len; | |
336 | FILE *input; | |
337 | struct cleanup *cleanups; | |
338 | ||
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); | |
344 | ||
345 | cleanups = make_cleanup (xfree, filename); | |
346 | make_cleanup (xfree, realname); | |
347 | ||
348 | input = fopen (filename, "r"); | |
349 | debugfile = filename; | |
350 | ||
351 | if (!input && debug_file_directory) | |
352 | { | |
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); | |
359 | ||
360 | make_cleanup (xfree, debugfile); | |
361 | input = fopen (debugfile, "r"); | |
362 | } | |
363 | ||
364 | if (!input && gdb_datadir) | |
365 | { | |
366 | /* Also try the same file in a subdirectory of gdb's data | |
367 | directory. */ | |
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); | |
374 | ||
375 | make_cleanup (xfree, debugfile); | |
376 | input = fopen (debugfile, "r"); | |
377 | } | |
378 | ||
379 | if (input) | |
380 | { | |
381 | source_python_script_for_objfile (objfile, input, debugfile); | |
382 | fclose (input); | |
383 | } | |
384 | ||
385 | do_cleanups (cleanups); | |
386 | } | |
387 | ||
388 | /* This is a new_objfile observer callback to auto-load scripts. | |
389 | ||
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 */ | |
393 | ||
394 | static void | |
395 | auto_load_new_objfile (struct objfile *objfile) | |
396 | { | |
397 | if (!objfile) | |
398 | { | |
399 | /* OBJFILE is NULL when loading a new "main" symbol-file. */ | |
400 | clear_section_scripts (); | |
401 | return; | |
402 | } | |
8a1ea21f | 403 | |
88a1906b DE |
404 | load_auto_scripts_for_objfile (objfile); |
405 | } | |
406 | ||
407 | /* Load any auto-loaded scripts for OBJFILE. */ | |
408 | ||
409 | void | |
410 | load_auto_scripts_for_objfile (struct objfile *objfile) | |
411 | { | |
a86caf66 | 412 | if (auto_load_scripts && gdbpy_global_auto_load) |
8a1ea21f DE |
413 | { |
414 | auto_load_objfile_script (objfile, GDBPY_AUTO_FILE_NAME); | |
415 | auto_load_section_scripts (objfile, GDBPY_AUTO_SECTION_NAME); | |
416 | } | |
417 | } | |
418 | \f | |
419 | /* Traversal function for htab_traverse. | |
420 | Print the entry if specified in the regex. */ | |
421 | ||
422 | static int | |
423 | maybe_print_section_script (void **slot, void *info) | |
424 | { | |
425 | struct loaded_script_entry *entry = *slot; | |
426 | ||
427 | if (re_exec (entry->name)) | |
428 | { | |
429 | printf_filtered (_("Script name: %s\n"), entry->name); | |
430 | printf_filtered (_(" Full name: %s\n"), | |
431 | entry->full_path ? entry->full_path : _("unknown")); | |
432 | } | |
433 | ||
434 | return 1; | |
435 | } | |
436 | ||
437 | /* "maint print section-scripts" command. */ | |
438 | ||
439 | static void | |
440 | maintenance_print_section_scripts (char *pattern, int from_tty) | |
441 | { | |
442 | struct auto_load_pspace_info *pspace_info; | |
443 | ||
444 | dont_repeat (); | |
445 | ||
446 | if (pattern && *pattern) | |
447 | { | |
448 | char *re_err = re_comp (pattern); | |
449 | ||
450 | if (re_err) | |
451 | error (_("Invalid regexp: %s"), re_err); | |
452 | ||
453 | printf_filtered (_("Objfile scripts matching %s:\n"), pattern); | |
454 | } | |
455 | else | |
456 | { | |
457 | re_comp (""); | |
458 | printf_filtered (_("Objfile scripts:\n")); | |
459 | } | |
460 | ||
461 | pspace_info = get_auto_load_pspace_data (current_program_space); | |
462 | if (pspace_info == NULL || pspace_info->loaded_scripts == NULL) | |
463 | return; | |
464 | ||
465 | immediate_quit++; | |
466 | htab_traverse_noresize (pspace_info->loaded_scripts, | |
467 | maybe_print_section_script, NULL); | |
468 | immediate_quit--; | |
469 | } | |
470 | \f | |
471 | void | |
472 | gdbpy_initialize_auto_load (void) | |
473 | { | |
474 | auto_load_pspace_data | |
475 | = register_program_space_data_with_cleanup (auto_load_pspace_data_cleanup); | |
476 | ||
477 | observer_attach_new_objfile (auto_load_new_objfile); | |
478 | ||
a86caf66 DE |
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."), | |
8a1ea21f | 485 | NULL, NULL, |
a86caf66 DE |
486 | &setlist, |
487 | &showlist); | |
8a1ea21f | 488 | |
9a2b4c1b MS |
489 | add_cmd ("section-scripts", class_maintenance, |
490 | maintenance_print_section_scripts, | |
8a1ea21f DE |
491 | _("Print dump of auto-loaded section scripts matching REGEXP."), |
492 | &maintenanceprintlist); | |
493 | } | |
88a1906b DE |
494 | |
495 | #else /* ! HAVE_PYTHON */ | |
496 | ||
497 | void | |
498 | load_auto_scripts_for_objfile (struct objfile *objfile) | |
499 | { | |
500 | } | |
501 | ||
502 | #endif /* ! HAVE_PYTHON */ |