Commit | Line | Data |
---|---|---|
c906108c | 1 | /* Core dump and executable file functions above target vector, for GDB. |
b6ba6518 KB |
2 | Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1996, 1997, 1998, |
3 | 1999, 2000, 2001 | |
c906108c SS |
4 | Free Software Foundation, Inc. |
5 | ||
c5aa993b | 6 | This file is part of GDB. |
c906108c | 7 | |
c5aa993b JM |
8 | This program is free software; you can redistribute it and/or modify |
9 | it under the terms of the GNU General Public License as published by | |
10 | the Free Software Foundation; either version 2 of the License, or | |
11 | (at your option) any later version. | |
c906108c | 12 | |
c5aa993b JM |
13 | This program is distributed in the hope that it will be useful, |
14 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | GNU General Public License for more details. | |
c906108c | 17 | |
c5aa993b JM |
18 | You should have received a copy of the GNU General Public License |
19 | along with this program; if not, write to the Free Software | |
20 | Foundation, Inc., 59 Temple Place - Suite 330, | |
21 | Boston, MA 02111-1307, USA. */ | |
c906108c SS |
22 | |
23 | #include "defs.h" | |
24 | #include "gdb_string.h" | |
25 | #include <errno.h> | |
26 | #include <signal.h> | |
27 | #include <fcntl.h> | |
c5aa993b | 28 | #include "frame.h" /* required by inferior.h */ |
c906108c SS |
29 | #include "inferior.h" |
30 | #include "symtab.h" | |
31 | #include "command.h" | |
32 | #include "gdbcmd.h" | |
1adeb98a | 33 | #include "symfile.h" |
c906108c SS |
34 | #include "bfd.h" |
35 | #include "target.h" | |
36 | #include "gdbcore.h" | |
37 | #include "dis-asm.h" | |
38 | #include "language.h" | |
39 | #include "gdb_stat.h" | |
40 | #include "symfile.h" | |
41 | #include "objfiles.h" | |
c5f0f3d0 | 42 | #include "completer.h" |
c906108c | 43 | |
c906108c SS |
44 | /* Local function declarations. */ |
45 | ||
a14ed312 KB |
46 | extern void _initialize_core (void); |
47 | static void call_extra_exec_file_hooks (char *filename); | |
c906108c SS |
48 | |
49 | /* You can have any number of hooks for `exec_file_command' command to call. | |
50 | If there's only one hook, it is set in exec_file_display hook. | |
51 | If there are two or more hooks, they are set in exec_file_extra_hooks[], | |
52 | and exec_file_display_hook is set to a function that calls all of them. | |
53 | This extra complexity is needed to preserve compatibility with | |
54 | old code that assumed that only one hook could be set, and which called | |
55 | exec_file_display_hook directly. */ | |
56 | ||
507f3c78 | 57 | typedef void (*hook_type) (char *); |
c906108c | 58 | |
c5aa993b | 59 | hook_type exec_file_display_hook; /* the original hook */ |
c906108c | 60 | static hook_type *exec_file_extra_hooks; /* array of additional hooks */ |
c5aa993b | 61 | static int exec_file_hook_count = 0; /* size of array */ |
c906108c SS |
62 | |
63 | /* Binary file diddling handle for the core file. */ | |
64 | ||
65 | bfd *core_bfd = NULL; | |
c906108c | 66 | \f |
c5aa993b | 67 | |
c906108c SS |
68 | /* Backward compatability with old way of specifying core files. */ |
69 | ||
70 | void | |
fba45db2 | 71 | core_file_command (char *filename, int from_tty) |
c906108c SS |
72 | { |
73 | struct target_ops *t; | |
74 | ||
c5aa993b | 75 | dont_repeat (); /* Either way, seems bogus. */ |
c906108c SS |
76 | |
77 | t = find_core_target (); | |
78 | if (t != NULL) | |
79 | if (!filename) | |
80 | (t->to_detach) (filename, from_tty); | |
81 | else | |
82 | { | |
c5aa993b JM |
83 | /* Yes, we were given the path of a core file. Do we already |
84 | have a symbol file? If not, can we determine it from the | |
85 | core file? If we can, do so. | |
86 | */ | |
c906108c | 87 | #ifdef HPUXHPPA |
c5aa993b JM |
88 | if (symfile_objfile == NULL) |
89 | { | |
90 | char *symfile; | |
91 | symfile = t->to_core_file_to_sym_file (filename); | |
92 | if (symfile) | |
93 | { | |
c2d11a7d | 94 | char *symfile_copy = xstrdup (symfile); |
c5aa993b | 95 | |
b8c9b27d | 96 | make_cleanup (xfree, symfile_copy); |
1adeb98a | 97 | symbol_file_add_main (symfile_copy, from_tty); |
c5aa993b JM |
98 | } |
99 | else | |
100 | warning ("Unknown symbols for '%s'; use the 'symbol-file' command.", filename); | |
101 | } | |
c906108c | 102 | #endif |
c5aa993b | 103 | (t->to_open) (filename, from_tty); |
c906108c SS |
104 | } |
105 | else | |
106 | error ("GDB can't read core files on this machine."); | |
107 | } | |
c906108c | 108 | \f |
c5aa993b | 109 | |
c906108c SS |
110 | /* If there are two or more functions that wish to hook into exec_file_command, |
111 | * this function will call all of the hook functions. */ | |
112 | ||
113 | static void | |
fba45db2 | 114 | call_extra_exec_file_hooks (char *filename) |
c906108c SS |
115 | { |
116 | int i; | |
117 | ||
118 | for (i = 0; i < exec_file_hook_count; i++) | |
c5aa993b | 119 | (*exec_file_extra_hooks[i]) (filename); |
c906108c SS |
120 | } |
121 | ||
122 | /* Call this to specify the hook for exec_file_command to call back. | |
123 | This is called from the x-window display code. */ | |
124 | ||
125 | void | |
dbb41be1 | 126 | specify_exec_file_hook (void (*hook) (char *)) |
c906108c SS |
127 | { |
128 | hook_type *new_array; | |
129 | ||
130 | if (exec_file_display_hook != NULL) | |
131 | { | |
132 | /* There's already a hook installed. Arrange to have both it | |
133 | * and the subsequent hooks called. */ | |
134 | if (exec_file_hook_count == 0) | |
135 | { | |
136 | /* If this is the first extra hook, initialize the hook array. */ | |
c5aa993b | 137 | exec_file_extra_hooks = (hook_type *) xmalloc (sizeof (hook_type)); |
c906108c SS |
138 | exec_file_extra_hooks[0] = exec_file_display_hook; |
139 | exec_file_display_hook = call_extra_exec_file_hooks; | |
140 | exec_file_hook_count = 1; | |
141 | } | |
142 | ||
143 | /* Grow the hook array by one and add the new hook to the end. | |
144 | Yes, it's inefficient to grow it by one each time but since | |
145 | this is hardly ever called it's not a big deal. */ | |
146 | exec_file_hook_count++; | |
147 | new_array = | |
148 | (hook_type *) xrealloc (exec_file_extra_hooks, | |
c5aa993b | 149 | exec_file_hook_count * sizeof (hook_type)); |
c906108c SS |
150 | exec_file_extra_hooks = new_array; |
151 | exec_file_extra_hooks[exec_file_hook_count - 1] = hook; | |
152 | } | |
153 | else | |
154 | exec_file_display_hook = hook; | |
155 | } | |
156 | ||
157 | /* The exec file must be closed before running an inferior. | |
158 | If it is needed again after the inferior dies, it must | |
159 | be reopened. */ | |
160 | ||
161 | void | |
fba45db2 | 162 | close_exec_file (void) |
c906108c | 163 | { |
c5aa993b | 164 | #if 0 /* FIXME */ |
c906108c SS |
165 | if (exec_bfd) |
166 | bfd_tempclose (exec_bfd); | |
167 | #endif | |
168 | } | |
169 | ||
170 | void | |
fba45db2 | 171 | reopen_exec_file (void) |
c906108c | 172 | { |
c5aa993b | 173 | #if 0 /* FIXME */ |
c906108c SS |
174 | if (exec_bfd) |
175 | bfd_reopen (exec_bfd); | |
176 | #else | |
177 | char *filename; | |
178 | int res; | |
179 | struct stat st; | |
180 | long mtime; | |
181 | ||
182 | /* Don't do anything if the current target isn't exec. */ | |
183 | if (exec_bfd == NULL || strcmp (target_shortname, "exec") != 0) | |
184 | return; | |
c5aa993b | 185 | |
c906108c | 186 | /* If the timestamp of the exec file has changed, reopen it. */ |
c2d11a7d | 187 | filename = xstrdup (bfd_get_filename (exec_bfd)); |
b8c9b27d | 188 | make_cleanup (xfree, filename); |
c5aa993b | 189 | mtime = bfd_get_mtime (exec_bfd); |
c906108c SS |
190 | res = stat (filename, &st); |
191 | ||
192 | if (mtime && mtime != st.st_mtime) | |
1adeb98a FN |
193 | { |
194 | exec_open (filename, 0); | |
195 | } | |
c906108c SS |
196 | #endif |
197 | } | |
198 | \f | |
199 | /* If we have both a core file and an exec file, | |
200 | print a warning if they don't go together. */ | |
201 | ||
202 | void | |
fba45db2 | 203 | validate_files (void) |
c906108c SS |
204 | { |
205 | if (exec_bfd && core_bfd) | |
206 | { | |
207 | if (!core_file_matches_executable_p (core_bfd, exec_bfd)) | |
208 | warning ("core file may not match specified executable file."); | |
c5aa993b | 209 | else if (bfd_get_mtime (exec_bfd) > bfd_get_mtime (core_bfd)) |
c906108c SS |
210 | warning ("exec file is newer than core file."); |
211 | } | |
212 | } | |
213 | ||
214 | /* Return the name of the executable file as a string. | |
215 | ERR nonzero means get error if there is none specified; | |
216 | otherwise return 0 in that case. */ | |
217 | ||
218 | char * | |
fba45db2 | 219 | get_exec_file (int err) |
c906108c | 220 | { |
c5aa993b JM |
221 | if (exec_bfd) |
222 | return bfd_get_filename (exec_bfd); | |
223 | if (!err) | |
224 | return NULL; | |
c906108c SS |
225 | |
226 | error ("No executable file specified.\n\ | |
227 | Use the \"file\" or \"exec-file\" command."); | |
228 | return NULL; | |
229 | } | |
c906108c | 230 | \f |
c5aa993b | 231 | |
c906108c SS |
232 | /* Report a memory error with error(). */ |
233 | ||
234 | void | |
fba45db2 | 235 | memory_error (int status, CORE_ADDR memaddr) |
c906108c | 236 | { |
d9fcf2fb JM |
237 | struct ui_file *tmp_stream = mem_fileopen (); |
238 | make_cleanup_ui_file_delete (tmp_stream); | |
2acceee2 | 239 | |
c906108c SS |
240 | if (status == EIO) |
241 | { | |
242 | /* Actually, address between memaddr and memaddr + len | |
c5aa993b | 243 | was out of bounds. */ |
2acceee2 JM |
244 | fprintf_unfiltered (tmp_stream, "Cannot access memory at address "); |
245 | print_address_numeric (memaddr, 1, tmp_stream); | |
c906108c SS |
246 | } |
247 | else | |
248 | { | |
2acceee2 JM |
249 | fprintf_filtered (tmp_stream, "Error accessing memory address "); |
250 | print_address_numeric (memaddr, 1, tmp_stream); | |
251 | fprintf_filtered (tmp_stream, ": %s.", | |
c5aa993b | 252 | safe_strerror (status)); |
c906108c | 253 | } |
2acceee2 JM |
254 | |
255 | error_stream (tmp_stream); | |
c906108c SS |
256 | } |
257 | ||
258 | /* Same as target_read_memory, but report an error if can't read. */ | |
259 | void | |
fba45db2 | 260 | read_memory (CORE_ADDR memaddr, char *myaddr, int len) |
c906108c SS |
261 | { |
262 | int status; | |
263 | status = target_read_memory (memaddr, myaddr, len); | |
264 | if (status != 0) | |
265 | memory_error (status, memaddr); | |
266 | } | |
267 | ||
c906108c | 268 | /* Like target_read_memory, but slightly different parameters. */ |
c906108c | 269 | int |
fba45db2 KB |
270 | dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr, unsigned int len, |
271 | disassemble_info *info) | |
c906108c SS |
272 | { |
273 | return target_read_memory (memaddr, (char *) myaddr, len); | |
274 | } | |
275 | ||
276 | /* Like memory_error with slightly different parameters. */ | |
277 | void | |
fba45db2 | 278 | dis_asm_memory_error (int status, bfd_vma memaddr, disassemble_info *info) |
c906108c SS |
279 | { |
280 | memory_error (status, memaddr); | |
281 | } | |
282 | ||
283 | /* Like print_address with slightly different parameters. */ | |
284 | void | |
fba45db2 | 285 | dis_asm_print_address (bfd_vma addr, struct disassemble_info *info) |
c906108c SS |
286 | { |
287 | print_address (addr, info->stream); | |
288 | } | |
289 | ||
290 | /* Same as target_write_memory, but report an error if can't write. */ | |
291 | void | |
fba45db2 | 292 | write_memory (CORE_ADDR memaddr, char *myaddr, int len) |
c906108c SS |
293 | { |
294 | int status; | |
295 | ||
296 | status = target_write_memory (memaddr, myaddr, len); | |
297 | if (status != 0) | |
298 | memory_error (status, memaddr); | |
299 | } | |
300 | ||
301 | /* Read an integer from debugged memory, given address and number of bytes. */ | |
302 | ||
303 | LONGEST | |
fba45db2 | 304 | read_memory_integer (CORE_ADDR memaddr, int len) |
c906108c SS |
305 | { |
306 | char buf[sizeof (LONGEST)]; | |
307 | ||
308 | read_memory (memaddr, buf, len); | |
309 | return extract_signed_integer (buf, len); | |
310 | } | |
311 | ||
312 | ULONGEST | |
fba45db2 | 313 | read_memory_unsigned_integer (CORE_ADDR memaddr, int len) |
c906108c SS |
314 | { |
315 | char buf[sizeof (ULONGEST)]; | |
316 | ||
317 | read_memory (memaddr, buf, len); | |
318 | return extract_unsigned_integer (buf, len); | |
319 | } | |
320 | ||
321 | void | |
fba45db2 | 322 | read_memory_string (CORE_ADDR memaddr, char *buffer, int max_len) |
c906108c | 323 | { |
c5aa993b | 324 | register char *cp; |
c906108c SS |
325 | register int i; |
326 | int cnt; | |
327 | ||
328 | cp = buffer; | |
329 | while (1) | |
330 | { | |
331 | if (cp - buffer >= max_len) | |
c5aa993b JM |
332 | { |
333 | buffer[max_len - 1] = '\0'; | |
334 | break; | |
335 | } | |
c906108c SS |
336 | cnt = max_len - (cp - buffer); |
337 | if (cnt > 8) | |
338 | cnt = 8; | |
339 | read_memory (memaddr + (int) (cp - buffer), cp, cnt); | |
340 | for (i = 0; i < cnt && *cp; i++, cp++) | |
c5aa993b | 341 | ; /* null body */ |
c906108c SS |
342 | |
343 | if (i < cnt && !*cp) | |
c5aa993b | 344 | break; |
c906108c SS |
345 | } |
346 | } | |
c906108c | 347 | \f |
c5aa993b | 348 | |
c906108c SS |
349 | #if 0 |
350 | /* Enable after 4.12. It is not tested. */ | |
351 | ||
352 | /* Search code. Targets can just make this their search function, or | |
353 | if the protocol has a less general search function, they can call this | |
354 | in the cases it can't handle. */ | |
355 | void | |
dbb41be1 KB |
356 | generic_search (int len, char *data, char *mask, CORE_ADDR startaddr, |
357 | int increment, CORE_ADDR lorange, CORE_ADDR hirange, | |
358 | CORE_ADDR *addr_found, char *data_found) | |
c906108c SS |
359 | { |
360 | int i; | |
361 | CORE_ADDR curaddr = startaddr; | |
362 | ||
363 | while (curaddr >= lorange && curaddr < hirange) | |
364 | { | |
365 | read_memory (curaddr, data_found, len); | |
366 | for (i = 0; i < len; ++i) | |
367 | if ((data_found[i] & mask[i]) != data[i]) | |
368 | goto try_again; | |
369 | /* It matches. */ | |
370 | *addr_found = curaddr; | |
371 | return; | |
372 | ||
373 | try_again: | |
374 | curaddr += increment; | |
375 | } | |
c5aa993b | 376 | *addr_found = (CORE_ADDR) 0; |
c906108c SS |
377 | return; |
378 | } | |
379 | #endif /* 0 */ | |
380 | \f | |
381 | /* The current default bfd target. Points to storage allocated for | |
382 | gnutarget_string. */ | |
383 | char *gnutarget; | |
384 | ||
385 | /* Same thing, except it is "auto" not NULL for the default case. */ | |
386 | static char *gnutarget_string; | |
387 | ||
a14ed312 | 388 | static void set_gnutarget_command (char *, int, struct cmd_list_element *); |
c906108c SS |
389 | |
390 | static void | |
fba45db2 | 391 | set_gnutarget_command (char *ignore, int from_tty, struct cmd_list_element *c) |
c906108c SS |
392 | { |
393 | if (STREQ (gnutarget_string, "auto")) | |
394 | gnutarget = NULL; | |
395 | else | |
396 | gnutarget = gnutarget_string; | |
397 | } | |
398 | ||
399 | /* Set the gnutarget. */ | |
400 | void | |
fba45db2 | 401 | set_gnutarget (char *newtarget) |
c906108c SS |
402 | { |
403 | if (gnutarget_string != NULL) | |
b8c9b27d | 404 | xfree (gnutarget_string); |
c906108c SS |
405 | gnutarget_string = savestring (newtarget, strlen (newtarget)); |
406 | set_gnutarget_command (NULL, 0, NULL); | |
407 | } | |
408 | ||
409 | void | |
fba45db2 | 410 | _initialize_core (void) |
c906108c SS |
411 | { |
412 | struct cmd_list_element *c; | |
413 | c = add_cmd ("core-file", class_files, core_file_command, | |
414 | "Use FILE as core dump for examining memory and registers.\n\ | |
415 | No arg means have no core file. This command has been superseded by the\n\ | |
416 | `target core' and `detach' commands.", &cmdlist); | |
417 | c->completer = filename_completer; | |
418 | ||
419 | c = add_set_cmd ("gnutarget", class_files, var_string_noescape, | |
c5aa993b JM |
420 | (char *) &gnutarget_string, |
421 | "Set the current BFD target.\n\ | |
c906108c | 422 | Use `set gnutarget auto' to specify automatic detection.", |
c5aa993b | 423 | &setlist); |
c906108c SS |
424 | c->function.sfunc = set_gnutarget_command; |
425 | add_show_from_set (c, &showlist); | |
426 | ||
427 | if (getenv ("GNUTARGET")) | |
428 | set_gnutarget (getenv ("GNUTARGET")); | |
429 | else | |
430 | set_gnutarget ("auto"); | |
431 | } |