Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / python / py-auto-load.c
1 /* GDB routines for supporting auto-loaded scripts.
2
3    Copyright (C) 2010-2013 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 "top.h"
23 #include "exceptions.h"
24 #include "gdbcmd.h"
25 #include "objfiles.h"
26 #include "python.h"
27 #include "cli/cli-cmds.h"
28 #include "auto-load.h"
29
30 #ifdef HAVE_PYTHON
31
32 #include "python-internal.h"
33
34 /* The section to look for Python auto-loaded scripts (in file formats that
35    support sections).
36    Each entry in this section is a byte of value 1, and then the nul-terminated
37    name of the script.  The script name may include a directory.
38    The leading byte is to allow upward compatible extensions.  */
39 #define GDBPY_AUTO_SECTION_NAME ".debug_gdb_scripts"
40
41 /* User-settable option to enable/disable auto-loading of Python scripts:
42    set auto-load python-scripts on|off
43    This is true if we should auto-load associated Python scripts when an
44    objfile is opened, false otherwise.  */
45 static int auto_load_python_scripts = 1;
46
47 static void gdbpy_load_auto_script_for_objfile (struct objfile *objfile,
48                                                 FILE *file,
49                                                 const char *filename);
50
51 /* "show" command for the auto_load_python_scripts configuration variable.  */
52
53 static void
54 show_auto_load_python_scripts (struct ui_file *file, int from_tty,
55                                struct cmd_list_element *c, const char *value)
56 {
57   fprintf_filtered (file, _("Auto-loading of Python scripts is %s.\n"), value);
58 }
59
60 /* Definition of script language for Python scripts.  */
61
62 static const struct script_language script_language_python
63   = { GDBPY_AUTO_FILE_NAME, gdbpy_load_auto_script_for_objfile };
64
65 /* Wrapper of source_python_script_for_objfile for script_language_python.  */
66
67 static void
68 gdbpy_load_auto_script_for_objfile (struct objfile *objfile, FILE *file,
69                                     const char *filename)
70 {
71   int is_safe;
72   struct auto_load_pspace_info *pspace_info;
73
74   is_safe = file_is_auto_load_safe (filename,
75                                     _("auto-load: Loading Python script \"%s\" "
76                                       "by extension for objfile \"%s\".\n"),
77                                     filename, objfile->name);
78
79   /* Add this script to the hash table too so "info auto-load python-scripts"
80      can print it.  */
81   pspace_info = get_auto_load_pspace_data_for_loading (current_program_space);
82   maybe_add_script (pspace_info, is_safe, filename, filename,
83                     &script_language_python);
84
85   if (is_safe)
86     source_python_script_for_objfile (objfile, file, filename);
87 }
88
89 /* Load scripts specified in OBJFILE.
90    START,END delimit a buffer containing a list of nul-terminated
91    file names.
92    SOURCE_NAME is used in error messages.
93
94    Scripts are found per normal "source -s" command processing.
95    First the script is looked for in $cwd.  If not found there the
96    source search path is used.
97
98    The section contains a list of path names of files containing
99    python code to load.  Each path is null-terminated.  */
100
101 static void
102 source_section_scripts (struct objfile *objfile, const char *source_name,
103                         const char *start, const char *end)
104 {
105   const char *p;
106   struct auto_load_pspace_info *pspace_info;
107
108   pspace_info = get_auto_load_pspace_data_for_loading (current_program_space);
109
110   for (p = start; p < end; ++p)
111     {
112       const char *file;
113       FILE *stream;
114       char *full_path;
115       int opened, in_hash_table;
116       struct cleanup *back_to;
117
118       if (*p != 1)
119         {
120           warning (_("Invalid entry in %s section"), GDBPY_AUTO_SECTION_NAME);
121           /* We could try various heuristics to find the next valid entry,
122              but it's safer to just punt.  */
123           break;
124         }
125       file = ++p;
126
127       while (p < end && *p != '\0')
128         ++p;
129       if (p == end)
130         {
131           char *buf = alloca (p - file + 1);
132
133           memcpy (buf, file, p - file);
134           buf[p - file] = '\0';
135           warning (_("Non-null-terminated path in %s: %s"),
136                    source_name, buf);
137           /* Don't load it.  */
138           break;
139         }
140       if (p == file)
141         {
142           warning (_("Empty path in %s"), source_name);
143           continue;
144         }
145
146       opened = find_and_open_script (file, 1 /*search_path*/,
147                                      &stream, &full_path);
148
149       back_to = make_cleanup (null_cleanup, NULL);
150       if (opened)
151         {
152           make_cleanup_fclose (stream);
153           make_cleanup (xfree, full_path);
154
155           if (!file_is_auto_load_safe (full_path,
156                                        _("auto-load: Loading Python script "
157                                          "\"%s\" from section \"%s\" of "
158                                          "objfile \"%s\".\n"),
159                                        full_path, GDBPY_AUTO_SECTION_NAME,
160                                        objfile->name))
161             opened = 0;
162         }
163       else
164         {
165           full_path = NULL;
166
167           /* We don't throw an error, the program is still debuggable.  */
168           if (script_not_found_warning_print (pspace_info))
169             warning (_("Missing auto-load scripts referenced in section %s\n\
170 of file %s\n\
171 Use `info auto-load python [REGEXP]' to list them."),
172                      GDBPY_AUTO_SECTION_NAME, objfile->name);
173         }
174
175       /* If one script isn't found it's not uncommon for more to not be
176          found either.  We don't want to print an error message for each
177          script, too much noise.  Instead, we print the warning once and tell
178          the user how to find the list of scripts that weren't loaded.
179
180          IWBN if complaints.c were more general-purpose.  */
181
182       in_hash_table = maybe_add_script (pspace_info, opened, file, full_path,
183                                         &script_language_python);
184
185       /* If this file is not currently loaded, load it.  */
186       if (opened && !in_hash_table)
187         source_python_script_for_objfile (objfile, stream, full_path);
188
189       do_cleanups (back_to);
190     }
191 }
192
193 /* Load scripts specified in section SECTION_NAME of OBJFILE.  */
194
195 static void
196 auto_load_section_scripts (struct objfile *objfile, const char *section_name)
197 {
198   bfd *abfd = objfile->obfd;
199   asection *scripts_sect;
200   bfd_byte *data = NULL;
201
202   scripts_sect = bfd_get_section_by_name (abfd, section_name);
203   if (scripts_sect == NULL)
204     return;
205
206   if (!bfd_get_full_section_contents (abfd, scripts_sect, &data))
207     warning (_("Couldn't read %s section of %s"),
208              section_name, bfd_get_filename (abfd));
209   else
210     {
211       struct cleanup *cleanups;
212       char *p = (char *) data;
213
214       cleanups = make_cleanup (xfree, p);
215       source_section_scripts (objfile, section_name, p,
216                               p + bfd_get_section_size (scripts_sect));
217       do_cleanups (cleanups);
218     }
219 }
220
221 /* Load any Python auto-loaded scripts for OBJFILE.  */
222
223 void
224 gdbpy_load_auto_scripts_for_objfile (struct objfile *objfile)
225 {
226   if (auto_load_python_scripts)
227     {
228       auto_load_objfile_script (objfile, &script_language_python);
229       auto_load_section_scripts (objfile, GDBPY_AUTO_SECTION_NAME);
230     }
231 }
232
233 /* Wrapper for "info auto-load python-scripts".  */
234
235 static void
236 info_auto_load_python_scripts (char *pattern, int from_tty)
237 {
238   auto_load_info_scripts (pattern, from_tty, &script_language_python);
239 }
240 \f
241 void
242 gdbpy_initialize_auto_load (void)
243 {
244   struct cmd_list_element *cmd;
245   char *cmd_name;
246
247   add_setshow_boolean_cmd ("python-scripts", class_support,
248                            &auto_load_python_scripts, _("\
249 Set the debugger's behaviour regarding auto-loaded Python scripts."), _("\
250 Show the debugger's behaviour regarding auto-loaded Python scripts."), _("\
251 If enabled, auto-loaded Python scripts are loaded when the debugger reads\n\
252 an executable or shared library.\n\
253 This options has security implications for untrusted inferiors."),
254                            NULL, show_auto_load_python_scripts,
255                            auto_load_set_cmdlist_get (),
256                            auto_load_show_cmdlist_get ());
257
258   add_setshow_boolean_cmd ("auto-load-scripts", class_support,
259                            &auto_load_python_scripts, _("\
260 Set the debugger's behaviour regarding auto-loaded Python scripts, "
261                                                                  "deprecated."),
262                            _("\
263 Show the debugger's behaviour regarding auto-loaded Python scripts, "
264                                                                  "deprecated."),
265                            NULL, NULL, show_auto_load_python_scripts,
266                            &setlist, &showlist);
267   cmd_name = "auto-load-scripts";
268   cmd = lookup_cmd (&cmd_name, setlist, "", -1, 1);
269   deprecate_cmd (cmd, "set auto-load python-scripts");
270
271   /* It is needed because lookup_cmd updates the CMD_NAME pointer.  */
272   cmd_name = "auto-load-scripts";
273   cmd = lookup_cmd (&cmd_name, showlist, "", -1, 1);
274   deprecate_cmd (cmd, "show auto-load python-scripts");
275
276   add_cmd ("python-scripts", class_info, info_auto_load_python_scripts,
277            _("Print the list of automatically loaded Python scripts.\n\
278 Usage: info auto-load python-scripts [REGEXP]"),
279            auto_load_info_cmdlist_get ());
280
281   cmd = add_info ("auto-load-scripts", info_auto_load_python_scripts, _("\
282 Print the list of automatically loaded Python scripts, deprecated."));
283   deprecate_cmd (cmd, "info auto-load python-scripts");
284 }
285
286 #else /* ! HAVE_PYTHON */
287
288 void
289 gdbpy_load_auto_scripts_for_objfile (struct objfile *objfile)
290 {
291 }
292
293 #endif /* ! HAVE_PYTHON */