Commit | Line | Data |
---|---|---|
8a1ea21f DE |
1 | /* GDB routines for supporting auto-loaded scripts. |
2 | ||
3 | Copyright (C) 2010 Free Software Foundation, Inc. | |
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 | ||
37 | Both gdbpy_auto_load && gdbpy_global_auto_load must be true to enable | |
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 DE |
84 | /* User-settable option to enable/disable auto-loading: |
85 | maint set python auto-load on|off | |
86 | This is true if we should auto-load python code when an objfile is opened, | |
8a1ea21f DE |
87 | false otherwise. */ |
88 | static int gdbpy_auto_load = 1; | |
89 | ||
90 | /* Per-program-space data key. */ | |
91 | static const struct program_space_data *auto_load_pspace_data; | |
92 | ||
93 | static void | |
94 | auto_load_pspace_data_cleanup (struct program_space *pspace, void *arg) | |
95 | { | |
96 | struct auto_load_pspace_info *info; | |
97 | ||
98 | info = program_space_data (pspace, auto_load_pspace_data); | |
99 | if (info != NULL) | |
100 | { | |
101 | if (info->loaded_scripts) | |
102 | htab_delete (info->loaded_scripts); | |
103 | xfree (info); | |
104 | } | |
105 | } | |
106 | ||
107 | /* Get the current autoload data. If none is found yet, add it now. This | |
108 | function always returns a valid object. */ | |
109 | ||
110 | static struct auto_load_pspace_info * | |
111 | get_auto_load_pspace_data (struct program_space *pspace) | |
112 | { | |
113 | struct auto_load_pspace_info *info; | |
114 | ||
115 | info = program_space_data (pspace, auto_load_pspace_data); | |
116 | if (info == NULL) | |
117 | { | |
118 | info = XZALLOC (struct auto_load_pspace_info); | |
119 | set_program_space_data (pspace, auto_load_pspace_data, info); | |
120 | } | |
121 | ||
122 | return info; | |
123 | } | |
124 | ||
125 | /* Hash function for the loaded script hash. */ | |
126 | ||
127 | static hashval_t | |
128 | hash_loaded_script_entry (const void *data) | |
129 | { | |
130 | const struct loaded_script_entry *e = data; | |
d59b6f6c | 131 | |
8a1ea21f DE |
132 | return htab_hash_string (e->name); |
133 | } | |
134 | ||
135 | /* Equality function for the loaded script hash. */ | |
136 | ||
137 | static int | |
138 | eq_loaded_script_entry (const void *a, const void *b) | |
139 | { | |
140 | const struct loaded_script_entry *ea = a; | |
141 | const struct loaded_script_entry *eb = b; | |
d59b6f6c | 142 | |
8a1ea21f DE |
143 | return strcmp (ea->name, eb->name) == 0; |
144 | } | |
145 | ||
146 | /* Create the hash table used for loaded scripts. | |
147 | Each entry is hashed by the full path name. */ | |
148 | ||
149 | static void | |
150 | create_loaded_scripts_hash (struct auto_load_pspace_info *pspace_info) | |
151 | { | |
152 | /* Choose 31 as the starting size of the hash table, somewhat arbitrarily. | |
153 | Space for each entry is obtained with one malloc so we can free them | |
154 | easily. */ | |
155 | ||
156 | pspace_info->loaded_scripts = htab_create (31, | |
157 | hash_loaded_script_entry, | |
158 | eq_loaded_script_entry, | |
159 | xfree); | |
160 | } | |
161 | ||
162 | /* Load scripts specified in OBJFILE. | |
163 | START,END delimit a buffer containing a list of nul-terminated | |
164 | file names. | |
165 | SOURCE_NAME is used in error messages. | |
166 | ||
167 | Scripts are found per normal "source -s" command processing. | |
168 | First the script is looked for in $cwd. If not found there the | |
169 | source search path is used. | |
170 | ||
171 | The section contains a list of path names of files containing | |
172 | python code to load. Each path is null-terminated. */ | |
173 | ||
174 | static void | |
175 | source_section_scripts (struct objfile *objfile, const char *source_name, | |
176 | const char *start, const char *end) | |
177 | { | |
178 | const char *p; | |
179 | struct auto_load_pspace_info *pspace_info; | |
180 | struct loaded_script_entry **slot, entry; | |
181 | ||
182 | pspace_info = get_auto_load_pspace_data (current_program_space); | |
183 | if (pspace_info->loaded_scripts == NULL) | |
184 | create_loaded_scripts_hash (pspace_info); | |
185 | ||
186 | for (p = start; p < end; ++p) | |
187 | { | |
188 | const char *file; | |
189 | FILE *stream; | |
190 | char *full_path; | |
191 | int opened, in_hash_table; | |
192 | ||
193 | if (*p != 1) | |
194 | { | |
195 | warning (_("Invalid entry in %s section"), GDBPY_AUTO_SECTION_NAME); | |
196 | /* We could try various heuristics to find the next valid entry, | |
197 | but it's safer to just punt. */ | |
198 | break; | |
199 | } | |
200 | file = ++p; | |
201 | ||
202 | while (p < end && *p != '\0') | |
203 | ++p; | |
204 | if (p == end) | |
205 | { | |
206 | char *buf = alloca (p - file + 1); | |
d59b6f6c | 207 | |
8a1ea21f DE |
208 | memcpy (buf, file, p - file); |
209 | buf[p - file] = '\0'; | |
210 | warning (_("Non-null-terminated path in %s: %s"), | |
211 | source_name, buf); | |
212 | /* Don't load it. */ | |
213 | break; | |
214 | } | |
215 | if (p == file) | |
216 | { | |
217 | warning (_("Empty path in %s"), source_name); | |
218 | continue; | |
219 | } | |
220 | ||
221 | opened = find_and_open_script (file, 1 /*search_path*/, | |
222 | &stream, &full_path); | |
223 | ||
224 | /* If the file is not found, we still record the file in the hash table, | |
225 | we only want to print an error message once. | |
226 | IWBN if complaints.c were more general-purpose. */ | |
227 | ||
228 | entry.name = file; | |
229 | if (opened) | |
230 | entry.full_path = full_path; | |
231 | else | |
232 | entry.full_path = NULL; | |
233 | slot = ((struct loaded_script_entry **) | |
234 | htab_find_slot (pspace_info->loaded_scripts, | |
235 | &entry, INSERT)); | |
236 | in_hash_table = *slot != NULL; | |
237 | ||
238 | /* If this file is not in the hash table, add it. */ | |
239 | if (! in_hash_table) | |
240 | { | |
241 | char *p; | |
d59b6f6c | 242 | |
8a1ea21f DE |
243 | *slot = xmalloc (sizeof (**slot) |
244 | + strlen (file) + 1 | |
245 | + (opened ? (strlen (full_path) + 1) : 0)); | |
246 | p = ((char*) *slot) + sizeof (**slot); | |
247 | strcpy (p, file); | |
248 | (*slot)->name = p; | |
249 | if (opened) | |
250 | { | |
251 | p += strlen (p) + 1; | |
252 | strcpy (p, full_path); | |
253 | (*slot)->full_path = p; | |
254 | } | |
255 | else | |
256 | (*slot)->full_path = NULL; | |
257 | } | |
258 | ||
259 | if (opened) | |
260 | free (full_path); | |
261 | ||
262 | if (! opened) | |
263 | { | |
264 | /* We don't throw an error, the program is still debuggable. | |
265 | Check in_hash_table to only print the warning once. */ | |
266 | if (! in_hash_table) | |
e78f4312 | 267 | warning (_("%s (referenced in %s): %s"), |
8a1ea21f DE |
268 | file, GDBPY_AUTO_SECTION_NAME, safe_strerror (errno)); |
269 | continue; | |
270 | } | |
271 | ||
272 | /* If this file is not currently loaded, load it. */ | |
273 | if (! in_hash_table) | |
274 | source_python_script_for_objfile (objfile, stream, file); | |
275 | } | |
276 | } | |
277 | ||
278 | /* Load scripts specified in section SECTION_NAME of OBJFILE. */ | |
279 | ||
280 | static void | |
281 | auto_load_section_scripts (struct objfile *objfile, const char *section_name) | |
282 | { | |
283 | bfd *abfd = objfile->obfd; | |
284 | asection *scripts_sect; | |
285 | bfd_size_type size; | |
286 | char *p; | |
287 | struct cleanup *cleanups; | |
288 | ||
289 | scripts_sect = bfd_get_section_by_name (abfd, section_name); | |
290 | if (scripts_sect == NULL) | |
291 | return; | |
292 | ||
293 | size = bfd_get_section_size (scripts_sect); | |
294 | p = xmalloc (size); | |
295 | ||
296 | cleanups = make_cleanup (xfree, p); | |
297 | ||
298 | if (bfd_get_section_contents (abfd, scripts_sect, p, (file_ptr) 0, size)) | |
299 | source_section_scripts (objfile, section_name, p, p + size); | |
300 | else | |
301 | warning (_("Couldn't read %s section of %s"), | |
302 | section_name, bfd_get_filename (abfd)); | |
303 | ||
304 | do_cleanups (cleanups); | |
305 | } | |
306 | ||
307 | /* Clear the table of loaded section scripts. */ | |
308 | ||
309 | static void | |
310 | clear_section_scripts (void) | |
311 | { | |
312 | struct program_space *pspace = current_program_space; | |
313 | struct auto_load_pspace_info *info; | |
314 | ||
315 | info = program_space_data (pspace, auto_load_pspace_data); | |
316 | if (info != NULL && info->loaded_scripts != NULL) | |
317 | { | |
318 | htab_delete (info->loaded_scripts); | |
319 | info->loaded_scripts = NULL; | |
320 | } | |
321 | } | |
322 | ||
323 | /* Look for the auto-load script associated with OBJFILE and load it. */ | |
324 | ||
325 | static void | |
326 | auto_load_objfile_script (struct objfile *objfile, const char *suffix) | |
327 | { | |
328 | char *realname; | |
329 | char *filename, *debugfile; | |
330 | int len; | |
331 | FILE *input; | |
332 | struct cleanup *cleanups; | |
333 | ||
334 | realname = gdb_realpath (objfile->name); | |
335 | len = strlen (realname); | |
336 | filename = xmalloc (len + strlen (suffix) + 1); | |
337 | memcpy (filename, realname, len); | |
338 | strcpy (filename + len, suffix); | |
339 | ||
340 | cleanups = make_cleanup (xfree, filename); | |
341 | make_cleanup (xfree, realname); | |
342 | ||
343 | input = fopen (filename, "r"); | |
344 | debugfile = filename; | |
345 | ||
346 | if (!input && debug_file_directory) | |
347 | { | |
348 | /* Also try the same file in the separate debug info directory. */ | |
349 | debugfile = xmalloc (strlen (filename) | |
350 | + strlen (debug_file_directory) + 1); | |
351 | strcpy (debugfile, debug_file_directory); | |
352 | /* FILENAME is absolute, so we don't need a "/" here. */ | |
353 | strcat (debugfile, filename); | |
354 | ||
355 | make_cleanup (xfree, debugfile); | |
356 | input = fopen (debugfile, "r"); | |
357 | } | |
358 | ||
359 | if (!input && gdb_datadir) | |
360 | { | |
361 | /* Also try the same file in a subdirectory of gdb's data | |
362 | directory. */ | |
363 | debugfile = xmalloc (strlen (gdb_datadir) + strlen (filename) | |
364 | + strlen ("/auto-load") + 1); | |
365 | strcpy (debugfile, gdb_datadir); | |
366 | strcat (debugfile, "/auto-load"); | |
367 | /* FILENAME is absolute, so we don't need a "/" here. */ | |
368 | strcat (debugfile, filename); | |
369 | ||
370 | make_cleanup (xfree, debugfile); | |
371 | input = fopen (debugfile, "r"); | |
372 | } | |
373 | ||
374 | if (input) | |
375 | { | |
376 | source_python_script_for_objfile (objfile, input, debugfile); | |
377 | fclose (input); | |
378 | } | |
379 | ||
380 | do_cleanups (cleanups); | |
381 | } | |
382 | ||
383 | /* This is a new_objfile observer callback to auto-load scripts. | |
384 | ||
385 | Two flavors of auto-loaded scripts are supported. | |
386 | 1) based on the path to the objfile | |
387 | 2) from .debug_gdb_scripts section */ | |
388 | ||
389 | static void | |
390 | auto_load_new_objfile (struct objfile *objfile) | |
391 | { | |
392 | if (!objfile) | |
393 | { | |
394 | /* OBJFILE is NULL when loading a new "main" symbol-file. */ | |
395 | clear_section_scripts (); | |
396 | return; | |
397 | } | |
8a1ea21f | 398 | |
88a1906b DE |
399 | load_auto_scripts_for_objfile (objfile); |
400 | } | |
401 | ||
402 | /* Load any auto-loaded scripts for OBJFILE. */ | |
403 | ||
404 | void | |
405 | load_auto_scripts_for_objfile (struct objfile *objfile) | |
406 | { | |
407 | if (gdbpy_auto_load && gdbpy_global_auto_load) | |
8a1ea21f DE |
408 | { |
409 | auto_load_objfile_script (objfile, GDBPY_AUTO_FILE_NAME); | |
410 | auto_load_section_scripts (objfile, GDBPY_AUTO_SECTION_NAME); | |
411 | } | |
412 | } | |
413 | \f | |
414 | /* Traversal function for htab_traverse. | |
415 | Print the entry if specified in the regex. */ | |
416 | ||
417 | static int | |
418 | maybe_print_section_script (void **slot, void *info) | |
419 | { | |
420 | struct loaded_script_entry *entry = *slot; | |
421 | ||
422 | if (re_exec (entry->name)) | |
423 | { | |
424 | printf_filtered (_("Script name: %s\n"), entry->name); | |
425 | printf_filtered (_(" Full name: %s\n"), | |
426 | entry->full_path ? entry->full_path : _("unknown")); | |
427 | } | |
428 | ||
429 | return 1; | |
430 | } | |
431 | ||
432 | /* "maint print section-scripts" command. */ | |
433 | ||
434 | static void | |
435 | maintenance_print_section_scripts (char *pattern, int from_tty) | |
436 | { | |
437 | struct auto_load_pspace_info *pspace_info; | |
438 | ||
439 | dont_repeat (); | |
440 | ||
441 | if (pattern && *pattern) | |
442 | { | |
443 | char *re_err = re_comp (pattern); | |
444 | ||
445 | if (re_err) | |
446 | error (_("Invalid regexp: %s"), re_err); | |
447 | ||
448 | printf_filtered (_("Objfile scripts matching %s:\n"), pattern); | |
449 | } | |
450 | else | |
451 | { | |
452 | re_comp (""); | |
453 | printf_filtered (_("Objfile scripts:\n")); | |
454 | } | |
455 | ||
456 | pspace_info = get_auto_load_pspace_data (current_program_space); | |
457 | if (pspace_info == NULL || pspace_info->loaded_scripts == NULL) | |
458 | return; | |
459 | ||
460 | immediate_quit++; | |
461 | htab_traverse_noresize (pspace_info->loaded_scripts, | |
462 | maybe_print_section_script, NULL); | |
463 | immediate_quit--; | |
464 | } | |
465 | \f | |
466 | void | |
467 | gdbpy_initialize_auto_load (void) | |
468 | { | |
469 | auto_load_pspace_data | |
470 | = register_program_space_data_with_cleanup (auto_load_pspace_data_cleanup); | |
471 | ||
472 | observer_attach_new_objfile (auto_load_new_objfile); | |
473 | ||
474 | add_setshow_boolean_cmd ("auto-load", class_maintenance, | |
475 | &gdbpy_auto_load, _("\ | |
476 | Enable or disable auto-loading of Python code when an object is opened."), _("\ | |
477 | Show whether Python code will be auto-loaded when an object is opened."), _("\ | |
478 | Enables or disables auto-loading of Python code when an object is opened."), | |
479 | NULL, NULL, | |
480 | &set_python_list, | |
481 | &show_python_list); | |
482 | ||
483 | add_cmd ("section-scripts", class_maintenance, maintenance_print_section_scripts, | |
484 | _("Print dump of auto-loaded section scripts matching REGEXP."), | |
485 | &maintenanceprintlist); | |
486 | } | |
88a1906b DE |
487 | |
488 | #else /* ! HAVE_PYTHON */ | |
489 | ||
490 | void | |
491 | load_auto_scripts_for_objfile (struct objfile *objfile) | |
492 | { | |
493 | } | |
494 | ||
495 | #endif /* ! HAVE_PYTHON */ |