File: | src/gnu/usr.bin/binutils/gdb/exec.c |
Warning: | line 108, column 4 Value stored to 'need_symtab_cleanup' is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* Work with executable files, for GDB. |
2 | |
3 | Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, |
4 | 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, |
5 | Inc. |
6 | |
7 | This file is part of GDB. |
8 | |
9 | This program is free software; you can redistribute it and/or modify |
10 | it under the terms of the GNU General Public License as published by |
11 | the Free Software Foundation; either version 2 of the License, or |
12 | (at your option) any later version. |
13 | |
14 | This program is distributed in the hope that it will be useful, |
15 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
16 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
17 | GNU General Public License for more details. |
18 | |
19 | You should have received a copy of the GNU General Public License |
20 | along with this program; if not, write to the Free Software |
21 | Foundation, Inc., 59 Temple Place - Suite 330, |
22 | Boston, MA 02111-1307, USA. */ |
23 | |
24 | #include "defs.h" |
25 | #include "frame.h" |
26 | #include "inferior.h" |
27 | #include "target.h" |
28 | #include "gdbcmd.h" |
29 | #include "language.h" |
30 | #include "symfile.h" |
31 | #include "objfiles.h" |
32 | #include "completer.h" |
33 | #include "value.h" |
34 | #include "exec.h" |
35 | |
36 | #include <fcntl.h> |
37 | #include "readline/readline.h" |
38 | #include "gdb_string.h" |
39 | |
40 | #include "gdbcore.h" |
41 | |
42 | #include <ctype.h> |
43 | #include "gdb_stat.h" |
44 | #ifndef O_BINARY0 |
45 | #define O_BINARY0 0 |
46 | #endif |
47 | |
48 | #include "xcoffsolib.h" |
49 | |
50 | struct vmap *map_vmap (bfd *, bfd *); |
51 | |
52 | void (*deprecated_file_changed_hook) (char *); |
53 | |
54 | /* Prototypes for local functions */ |
55 | |
56 | static void exec_close (int); |
57 | |
58 | static void file_command (char *, int); |
59 | |
60 | static void set_section_command (char *, int); |
61 | |
62 | static void exec_files_info (struct target_ops *); |
63 | |
64 | static int ignore (CORE_ADDR, char *); |
65 | |
66 | static void init_exec_ops (void); |
67 | |
68 | void _initialize_exec (void); |
69 | |
70 | /* The target vector for executable files. */ |
71 | |
72 | struct target_ops exec_ops; |
73 | |
74 | /* The Binary File Descriptor handle for the executable file. */ |
75 | |
76 | bfd *exec_bfd = NULL((void*)0); |
77 | |
78 | /* Whether to open exec and core files read-only or read-write. */ |
79 | |
80 | int write_files = 0; |
81 | |
82 | struct vmap *vmap; |
83 | |
84 | void |
85 | exec_open (char *args, int from_tty) |
86 | { |
87 | target_preopen (from_tty); |
88 | exec_file_attach (args, from_tty); |
89 | } |
90 | |
91 | static void |
92 | exec_close (int quitting) |
93 | { |
94 | int need_symtab_cleanup = 0; |
95 | struct vmap *vp, *nxt; |
96 | |
97 | for (nxt = vmap; nxt != NULL((void*)0);) |
98 | { |
99 | vp = nxt; |
100 | nxt = vp->nxt; |
101 | |
102 | /* if there is an objfile associated with this bfd, |
103 | free_objfile() will do proper cleanup of objfile *and* bfd. */ |
104 | |
105 | if (vp->objfile) |
106 | { |
107 | free_objfile (vp->objfile); |
108 | need_symtab_cleanup = 1; |
Value stored to 'need_symtab_cleanup' is never read | |
109 | } |
110 | else if (vp->bfd != exec_bfd) |
111 | /* FIXME-leak: We should be freeing vp->name too, I think. */ |
112 | if (!bfd_close (vp->bfd)) |
113 | warning ("cannot close \"%s\": %s", |
114 | vp->name, bfd_errmsg (bfd_get_error ())); |
115 | |
116 | /* FIXME: This routine is #if 0'd in symfile.c. What should we |
117 | be doing here? Should we just free everything in |
118 | vp->objfile->symtabs? Should free_objfile do that? |
119 | FIXME-as-well: free_objfile already free'd vp->name, so it isn't |
120 | valid here. */ |
121 | free_named_symtabs (vp->name); |
122 | xfree (vp); |
123 | } |
124 | |
125 | vmap = NULL((void*)0); |
126 | |
127 | if (exec_bfd) |
128 | { |
129 | char *name = bfd_get_filename (exec_bfd)((char *) (exec_bfd)->filename); |
130 | |
131 | if (!bfd_close (exec_bfd)) |
132 | warning ("cannot close \"%s\": %s", |
133 | name, bfd_errmsg (bfd_get_error ())); |
134 | xfree (name); |
135 | exec_bfd = NULL((void*)0); |
136 | } |
137 | |
138 | if (exec_ops.to_sections) |
139 | { |
140 | xfree (exec_ops.to_sections); |
141 | exec_ops.to_sections = NULL((void*)0); |
142 | exec_ops.to_sections_end = NULL((void*)0); |
143 | } |
144 | } |
145 | |
146 | void |
147 | exec_file_clear (int from_tty) |
148 | { |
149 | /* Remove exec file. */ |
150 | unpush_target (&exec_ops); |
151 | |
152 | if (from_tty) |
153 | printf_unfiltered ("No executable file now.\n"); |
154 | } |
155 | |
156 | /* Process the first arg in ARGS as the new exec file. |
157 | |
158 | This function is intended to be behave essentially the same |
159 | as exec_file_command, except that the latter will detect when |
160 | a target is being debugged, and will ask the user whether it |
161 | should be shut down first. (If the answer is "no", then the |
162 | new file is ignored.) |
163 | |
164 | This file is used by exec_file_command, to do the work of opening |
165 | and processing the exec file after any prompting has happened. |
166 | |
167 | And, it is used by child_attach, when the attach command was |
168 | given a pid but not a exec pathname, and the attach command could |
169 | figure out the pathname from the pid. (In this case, we shouldn't |
170 | ask the user whether the current target should be shut down -- |
171 | we're supplying the exec pathname late for good reason.) |
172 | |
173 | ARGS is assumed to be the filename. */ |
174 | |
175 | void |
176 | exec_file_attach (char *filename, int from_tty) |
177 | { |
178 | /* Remove any previous exec file. */ |
179 | unpush_target (&exec_ops); |
180 | |
181 | /* Now open and digest the file the user requested, if any. */ |
182 | |
183 | if (!filename) |
184 | { |
185 | if (from_tty) |
186 | printf_unfiltered ("No executable file now.\n"); |
187 | } |
188 | else |
189 | { |
190 | char *scratch_pathname; |
191 | int scratch_chan; |
192 | |
193 | scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST0x01, filename, |
194 | write_files ? O_RDWR0x0002 | O_BINARY0 : O_RDONLY0x0000 | O_BINARY0, 0, |
195 | &scratch_pathname); |
196 | #if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__) |
197 | if (scratch_chan < 0) |
198 | { |
199 | char *exename = alloca (strlen (filename) + 5)__builtin_alloca(strlen (filename) + 5); |
200 | strcat (strcpy (exename, filename), ".exe"); |
201 | scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST0x01, exename, |
202 | write_files ? O_RDWR0x0002 | O_BINARY0 : O_RDONLY0x0000 | O_BINARY0, 0, |
203 | &scratch_pathname); |
204 | } |
205 | #endif |
206 | if (scratch_chan < 0) |
207 | perror_with_name (filename); |
208 | exec_bfd = bfd_fdopenr (scratch_pathname, gnutarget, scratch_chan); |
209 | |
210 | if (!exec_bfd) |
211 | error ("\"%s\": could not open as an executable file: %s", |
212 | scratch_pathname, bfd_errmsg (bfd_get_error ())); |
213 | |
214 | /* At this point, scratch_pathname and exec_bfd->name both point to the |
215 | same malloc'd string. However exec_close() will attempt to free it |
216 | via the exec_bfd->name pointer, so we need to make another copy and |
217 | leave exec_bfd as the new owner of the original copy. */ |
218 | scratch_pathname = xstrdup (scratch_pathname); |
219 | make_cleanup (xfree, scratch_pathname); |
220 | |
221 | if (!bfd_check_format (exec_bfd, bfd_object)) |
222 | { |
223 | /* Make sure to close exec_bfd, or else "run" might try to use |
224 | it. */ |
225 | exec_close (0); |
226 | error ("\"%s\": not in executable format: %s", |
227 | scratch_pathname, bfd_errmsg (bfd_get_error ())); |
228 | } |
229 | |
230 | /* FIXME - This should only be run for RS6000, but the ifdef is a poor |
231 | way to accomplish. */ |
232 | #ifdef DEPRECATED_IBM6000_TARGET |
233 | /* Setup initial vmap. */ |
234 | |
235 | map_vmap (exec_bfd, 0); |
236 | if (vmap == NULL((void*)0)) |
237 | { |
238 | /* Make sure to close exec_bfd, or else "run" might try to use |
239 | it. */ |
240 | exec_close (0); |
241 | error ("\"%s\": can't find the file sections: %s", |
242 | scratch_pathname, bfd_errmsg (bfd_get_error ())); |
243 | } |
244 | #endif /* DEPRECATED_IBM6000_TARGET */ |
245 | |
246 | if (build_section_table (exec_bfd, &exec_ops.to_sections, |
247 | &exec_ops.to_sections_end)) |
248 | { |
249 | /* Make sure to close exec_bfd, or else "run" might try to use |
250 | it. */ |
251 | exec_close (0); |
252 | error ("\"%s\": can't find the file sections: %s", |
253 | scratch_pathname, bfd_errmsg (bfd_get_error ())); |
254 | } |
255 | |
256 | #ifdef DEPRECATED_HPUX_TEXT_END |
257 | DEPRECATED_HPUX_TEXT_END (&exec_ops); |
258 | #endif |
259 | |
260 | validate_files (); |
261 | |
262 | set_gdbarch_from_file (exec_bfd); |
263 | |
264 | push_target (&exec_ops); |
265 | |
266 | /* Tell display code (if any) about the changed file name. */ |
267 | if (deprecated_exec_file_display_hook) |
268 | (*deprecated_exec_file_display_hook) (filename); |
269 | } |
270 | bfd_cache_close_all (); |
271 | } |
272 | |
273 | /* Process the first arg in ARGS as the new exec file. |
274 | |
275 | Note that we have to explicitly ignore additional args, since we can |
276 | be called from file_command(), which also calls symbol_file_command() |
277 | which can take multiple args. |
278 | |
279 | If ARGS is NULL, we just want to close the exec file. */ |
280 | |
281 | static void |
282 | exec_file_command (char *args, int from_tty) |
283 | { |
284 | char **argv; |
285 | char *filename; |
286 | |
287 | target_preopen (from_tty); |
288 | |
289 | if (args) |
290 | { |
291 | /* Scan through the args and pick up the first non option arg |
292 | as the filename. */ |
293 | |
294 | argv = buildargv (args); |
295 | if (argv == NULL((void*)0)) |
296 | nomem (0); |
297 | |
298 | make_cleanup_freeargv (argv); |
299 | |
300 | for (; (*argv != NULL((void*)0)) && (**argv == '-'); argv++) |
301 | {; |
302 | } |
303 | if (*argv == NULL((void*)0)) |
304 | error ("No executable file name was specified"); |
305 | |
306 | filename = tilde_expand (*argv); |
307 | make_cleanup (xfree, filename); |
308 | exec_file_attach (filename, from_tty); |
309 | } |
310 | else |
311 | exec_file_attach (NULL((void*)0), from_tty); |
312 | } |
313 | |
314 | /* Set both the exec file and the symbol file, in one command. |
315 | What a novelty. Why did GDB go through four major releases before this |
316 | command was added? */ |
317 | |
318 | static void |
319 | file_command (char *arg, int from_tty) |
320 | { |
321 | /* FIXME, if we lose on reading the symbol file, we should revert |
322 | the exec file, but that's rough. */ |
323 | exec_file_command (arg, from_tty); |
324 | symbol_file_command (arg, from_tty); |
325 | if (deprecated_file_changed_hook) |
326 | deprecated_file_changed_hook (arg); |
327 | } |
328 | |
329 | |
330 | /* Locate all mappable sections of a BFD file. |
331 | table_pp_char is a char * to get it through bfd_map_over_sections; |
332 | we cast it back to its proper type. */ |
333 | |
334 | static void |
335 | add_to_section_table (bfd *abfd, struct bfd_section *asect, |
336 | void *table_pp_char) |
337 | { |
338 | struct section_table **table_pp = (struct section_table **) table_pp_char; |
339 | flagword aflag; |
340 | |
341 | aflag = bfd_get_section_flags (abfd, asect)((asect)->flags + 0); |
342 | if (!(aflag & SEC_ALLOC0x001)) |
343 | return; |
344 | if (0 == bfd_section_size (abfd, asect)((asect)->_raw_size)) |
345 | return; |
346 | (*table_pp)->bfd = abfd; |
347 | (*table_pp)->the_bfd_section = asect; |
348 | (*table_pp)->addr = bfd_section_vma (abfd, asect)((asect)->vma); |
349 | (*table_pp)->endaddr = (*table_pp)->addr + bfd_section_size (abfd, asect)((asect)->_raw_size); |
350 | (*table_pp)++; |
351 | } |
352 | |
353 | /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR. |
354 | Returns 0 if OK, 1 on error. */ |
355 | |
356 | int |
357 | build_section_table (struct bfd *some_bfd, struct section_table **start, |
358 | struct section_table **end) |
359 | { |
360 | unsigned count; |
361 | |
362 | count = bfd_count_sections (some_bfd)((some_bfd)->section_count); |
363 | if (*start) |
364 | xfree (* start); |
365 | *start = (struct section_table *) xmalloc (count * sizeof (**start)); |
366 | *end = *start; |
367 | bfd_map_over_sections (some_bfd, add_to_section_table, (char *) end); |
368 | if (*end > *start + count) |
369 | internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/exec.c", __LINE__369, "failed internal consistency check"); |
370 | /* We could realloc the table, but it probably loses for most files. */ |
371 | return 0; |
372 | } |
373 | |
374 | static void |
375 | bfdsec_to_vmap (struct bfd *abfd, struct bfd_section *sect, void *arg3) |
376 | { |
377 | struct vmap_and_bfd *vmap_bfd = (struct vmap_and_bfd *) arg3; |
378 | struct vmap *vp; |
379 | |
380 | vp = vmap_bfd->pvmap; |
381 | |
382 | if ((bfd_get_section_flags (abfd, sect)((sect)->flags + 0) & SEC_LOAD0x002) == 0) |
383 | return; |
384 | |
385 | if (DEPRECATED_STREQ (bfd_section_name (abfd, sect), ".text")(strcmp ((((sect)->name)), (".text")) == 0)) |
386 | { |
387 | vp->tstart = bfd_section_vma (abfd, sect)((sect)->vma); |
388 | vp->tend = vp->tstart + bfd_section_size (abfd, sect)((sect)->_raw_size); |
389 | vp->tvma = bfd_section_vma (abfd, sect)((sect)->vma); |
390 | vp->toffs = sect->filepos; |
391 | } |
392 | else if (DEPRECATED_STREQ (bfd_section_name (abfd, sect), ".data")(strcmp ((((sect)->name)), (".data")) == 0)) |
393 | { |
394 | vp->dstart = bfd_section_vma (abfd, sect)((sect)->vma); |
395 | vp->dend = vp->dstart + bfd_section_size (abfd, sect)((sect)->_raw_size); |
396 | vp->dvma = bfd_section_vma (abfd, sect)((sect)->vma); |
397 | } |
398 | /* Silently ignore other types of sections. (FIXME?) */ |
399 | } |
400 | |
401 | /* Make a vmap for ABFD which might be a member of the archive ARCH. |
402 | Return the new vmap. */ |
403 | |
404 | struct vmap * |
405 | map_vmap (bfd *abfd, bfd *arch) |
406 | { |
407 | struct vmap_and_bfd vmap_bfd; |
408 | struct vmap *vp, **vpp; |
409 | |
410 | vp = (struct vmap *) xmalloc (sizeof (*vp)); |
411 | memset ((char *) vp, '\0', sizeof (*vp)); |
412 | vp->nxt = 0; |
413 | vp->bfd = abfd; |
414 | vp->name = bfd_get_filename (arch ? arch : abfd)((char *) (arch ? arch : abfd)->filename); |
415 | vp->member = arch ? bfd_get_filename (abfd)((char *) (abfd)->filename) : ""; |
416 | |
417 | vmap_bfd.pbfd = arch; |
418 | vmap_bfd.pvmap = vp; |
419 | bfd_map_over_sections (abfd, bfdsec_to_vmap, &vmap_bfd); |
420 | |
421 | /* Find the end of the list and append. */ |
422 | for (vpp = &vmap; *vpp; vpp = &(*vpp)->nxt) |
423 | ; |
424 | *vpp = vp; |
425 | |
426 | return vp; |
427 | } |
428 | |
429 | /* Read or write the exec file. |
430 | |
431 | Args are address within a BFD file, address within gdb address-space, |
432 | length, and a flag indicating whether to read or write. |
433 | |
434 | Result is a length: |
435 | |
436 | 0: We cannot handle this address and length. |
437 | > 0: We have handled N bytes starting at this address. |
438 | (If N == length, we did it all.) We might be able |
439 | to handle more bytes beyond this length, but no |
440 | promises. |
441 | < 0: We cannot handle this address, but if somebody |
442 | else handles (-N) bytes, we can start from there. |
443 | |
444 | The same routine is used to handle both core and exec files; |
445 | we just tail-call it with more arguments to select between them. */ |
446 | |
447 | int |
448 | xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write, |
449 | struct mem_attrib *attrib, |
450 | struct target_ops *target) |
451 | { |
452 | int res; |
453 | struct section_table *p; |
454 | CORE_ADDR nextsectaddr, memend; |
455 | asection *section = NULL((void*)0); |
456 | |
457 | if (len <= 0) |
458 | internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/exec.c", __LINE__458, "failed internal consistency check"); |
459 | |
460 | if (overlay_debugging) |
461 | { |
462 | section = find_pc_overlay (memaddr); |
463 | if (pc_in_unmapped_range (memaddr, section)) |
464 | memaddr = overlay_mapped_address (memaddr, section); |
465 | } |
466 | |
467 | memend = memaddr + len; |
468 | nextsectaddr = memend; |
469 | |
470 | for (p = target->to_sections; p < target->to_sections_end; p++) |
471 | { |
472 | if (overlay_debugging && section && p->the_bfd_section && |
473 | strcmp (section->name, p->the_bfd_section->name) != 0) |
474 | continue; /* not the section we need */ |
475 | if (memaddr >= p->addr) |
476 | { |
477 | if (memend <= p->endaddr) |
478 | { |
479 | /* Entire transfer is within this section. */ |
480 | if (write) |
481 | res = bfd_set_section_contents (p->bfd, p->the_bfd_section, |
482 | myaddr, memaddr - p->addr, |
483 | len); |
484 | else |
485 | res = bfd_get_section_contents (p->bfd, p->the_bfd_section, |
486 | myaddr, memaddr - p->addr, |
487 | len); |
488 | return (res != 0) ? len : 0; |
489 | } |
490 | else if (memaddr >= p->endaddr) |
491 | { |
492 | /* This section ends before the transfer starts. */ |
493 | continue; |
494 | } |
495 | else |
496 | { |
497 | /* This section overlaps the transfer. Just do half. */ |
498 | len = p->endaddr - memaddr; |
499 | if (write) |
500 | res = bfd_set_section_contents (p->bfd, p->the_bfd_section, |
501 | myaddr, memaddr - p->addr, |
502 | len); |
503 | else |
504 | res = bfd_get_section_contents (p->bfd, p->the_bfd_section, |
505 | myaddr, memaddr - p->addr, |
506 | len); |
507 | return (res != 0) ? len : 0; |
508 | } |
509 | } |
510 | else |
511 | nextsectaddr = min (nextsectaddr, p->addr)((nextsectaddr) < (p->addr) ? (nextsectaddr) : (p->addr )); |
512 | } |
513 | |
514 | if (nextsectaddr >= memend) |
515 | return 0; /* We can't help */ |
516 | else |
517 | return -(nextsectaddr - memaddr); /* Next boundary where we can help */ |
518 | } |
519 | |
520 | |
521 | void |
522 | print_section_info (struct target_ops *t, bfd *abfd) |
523 | { |
524 | struct section_table *p; |
525 | /* FIXME: 16 is not wide enough when TARGET_ADDR_BIT > 64. */ |
526 | int wid = TARGET_ADDR_BIT(gdbarch_addr_bit (current_gdbarch)) <= 32 ? 8 : 16; |
527 | |
528 | printf_filtered ("\t`%s', ", bfd_get_filename (abfd)((char *) (abfd)->filename)); |
529 | wrap_here (" "); |
530 | printf_filtered ("file type %s.\n", bfd_get_target (abfd)((abfd)->xvec->name)); |
531 | if (abfd == exec_bfd) |
532 | { |
533 | printf_filtered ("\tEntry point: "); |
534 | print_address_numeric (bfd_get_start_address (abfd)((abfd)->start_address), 1, gdb_stdout); |
535 | printf_filtered ("\n"); |
536 | } |
537 | for (p = t->to_sections; p < t->to_sections_end; p++) |
538 | { |
539 | printf_filtered ("\t%s", hex_string_custom (p->addr, wid)); |
540 | printf_filtered (" - %s", hex_string_custom (p->endaddr, wid)); |
541 | |
542 | /* FIXME: A format of "08l" is not wide enough for file offsets |
543 | larger than 4GB. OTOH, making it "016l" isn't desirable either |
544 | since most output will then be much wider than necessary. It |
545 | may make sense to test the size of the file and choose the |
546 | format string accordingly. */ |
547 | if (info_verbose) |
548 | printf_filtered (" @ %s", |
549 | hex_string_custom (p->the_bfd_section->filepos, 8)); |
550 | printf_filtered (" is %s", bfd_section_name (p->bfd, p->the_bfd_section)((p->the_bfd_section)->name)); |
551 | if (p->bfd != abfd) |
552 | { |
553 | printf_filtered (" in %s", bfd_get_filename (p->bfd)((char *) (p->bfd)->filename)); |
554 | } |
555 | printf_filtered ("\n"); |
556 | } |
557 | } |
558 | |
559 | static void |
560 | exec_files_info (struct target_ops *t) |
561 | { |
562 | print_section_info (t, exec_bfd); |
563 | |
564 | if (vmap) |
565 | { |
566 | struct vmap *vp; |
567 | |
568 | printf_unfiltered ("\tMapping info for file `%s'.\n", vmap->name); |
569 | printf_unfiltered ("\t %*s %*s %*s %*s %8.8s %s\n", |
570 | strlen_paddr (), "tstart", |
571 | strlen_paddr (), "tend", |
572 | strlen_paddr (), "dstart", |
573 | strlen_paddr (), "dend", |
574 | "section", |
575 | "file(member)"); |
576 | |
577 | for (vp = vmap; vp; vp = vp->nxt) |
578 | printf_unfiltered ("\t0x%s 0x%s 0x%s 0x%s %s%s%s%s\n", |
579 | paddr (vp->tstart), |
580 | paddr (vp->tend), |
581 | paddr (vp->dstart), |
582 | paddr (vp->dend), |
583 | vp->name, |
584 | *vp->member ? "(" : "", vp->member, |
585 | *vp->member ? ")" : ""); |
586 | } |
587 | } |
588 | |
589 | /* msnyder 5/21/99: |
590 | exec_set_section_offsets sets the offsets of all the sections |
591 | in the exec objfile. */ |
592 | |
593 | void |
594 | exec_set_section_offsets (bfd_signed_vma text_off, bfd_signed_vma data_off, |
595 | bfd_signed_vma bss_off) |
596 | { |
597 | struct section_table *sect; |
598 | |
599 | for (sect = exec_ops.to_sections; |
600 | sect < exec_ops.to_sections_end; |
601 | sect++) |
602 | { |
603 | flagword flags; |
604 | |
605 | flags = bfd_get_section_flags (exec_bfd, sect->the_bfd_section)((sect->the_bfd_section)->flags + 0); |
606 | |
607 | if (flags & SEC_CODE0x020) |
608 | { |
609 | sect->addr += text_off; |
610 | sect->endaddr += text_off; |
611 | } |
612 | else if (flags & (SEC_DATA0x040 | SEC_LOAD0x002)) |
613 | { |
614 | sect->addr += data_off; |
615 | sect->endaddr += data_off; |
616 | } |
617 | else if (flags & SEC_ALLOC0x001) |
618 | { |
619 | sect->addr += bss_off; |
620 | sect->endaddr += bss_off; |
621 | } |
622 | } |
623 | } |
624 | |
625 | static void |
626 | set_section_command (char *args, int from_tty) |
627 | { |
628 | struct section_table *p; |
629 | char *secname; |
630 | unsigned seclen; |
631 | unsigned long secaddr; |
632 | char secprint[100]; |
633 | long offset; |
634 | |
635 | if (args == 0) |
636 | error ("Must specify section name and its virtual address"); |
637 | |
638 | /* Parse out section name */ |
639 | for (secname = args; !isspace (*args); args++); |
640 | seclen = args - secname; |
641 | |
642 | /* Parse out new virtual address */ |
643 | secaddr = parse_and_eval_address (args); |
644 | |
645 | for (p = exec_ops.to_sections; p < exec_ops.to_sections_end; p++) |
646 | { |
647 | if (!strncmp (secname, bfd_section_name (exec_bfd, p->the_bfd_section)((p->the_bfd_section)->name), seclen) |
648 | && bfd_section_name (exec_bfd, p->the_bfd_section)((p->the_bfd_section)->name)[seclen] == '\0') |
649 | { |
650 | offset = secaddr - p->addr; |
651 | p->addr += offset; |
652 | p->endaddr += offset; |
653 | if (from_tty) |
654 | exec_files_info (&exec_ops); |
655 | return; |
656 | } |
657 | } |
658 | if (seclen >= sizeof (secprint)) |
659 | seclen = sizeof (secprint) - 1; |
660 | strncpy (secprint, secname, seclen); |
661 | secprint[seclen] = '\0'; |
662 | error ("Section %s not found", secprint); |
663 | } |
664 | |
665 | /* If mourn is being called in all the right places, this could be say |
666 | `gdb internal error' (since generic_mourn calls |
667 | breakpoint_init_inferior). */ |
668 | |
669 | static int |
670 | ignore (CORE_ADDR addr, char *contents) |
671 | { |
672 | return 0; |
673 | } |
674 | |
675 | /* Find mapped memory. */ |
676 | |
677 | extern void |
678 | exec_set_find_memory_regions (int (*func) (int (*) (CORE_ADDR, |
679 | unsigned long, |
680 | int, int, int, |
681 | void *), |
682 | void *)) |
683 | { |
684 | exec_ops.to_find_memory_regions = func; |
685 | } |
686 | |
687 | static char *exec_make_note_section (bfd *, int *); |
688 | |
689 | /* Fill in the exec file target vector. Very few entries need to be |
690 | defined. */ |
691 | |
692 | static void |
693 | init_exec_ops (void) |
694 | { |
695 | exec_ops.to_shortname = "exec"; |
696 | exec_ops.to_longname = "Local exec file"; |
697 | exec_ops.to_doc = "Use an executable file as a target.\n\ |
698 | Specify the filename of the executable file."; |
699 | exec_ops.to_open = exec_open; |
700 | exec_ops.to_close = exec_close; |
701 | exec_ops.to_attach = find_default_attach; |
702 | exec_ops.deprecated_xfer_memory = xfer_memory; |
703 | exec_ops.to_files_info = exec_files_info; |
704 | exec_ops.to_insert_breakpoint = ignore; |
705 | exec_ops.to_remove_breakpoint = ignore; |
706 | exec_ops.to_create_inferior = find_default_create_inferior; |
707 | exec_ops.to_stratum = file_stratum; |
708 | exec_ops.to_has_memory = 1; |
709 | exec_ops.to_make_corefile_notes = exec_make_note_section; |
710 | exec_ops.to_magic = OPS_MAGIC3840; |
711 | } |
712 | |
713 | void |
714 | _initialize_exec (void) |
715 | { |
716 | struct cmd_list_element *c; |
717 | |
718 | init_exec_ops (); |
719 | |
720 | if (!dbx_commands) |
721 | { |
722 | c = add_cmd ("file", class_files, file_command, |
723 | "Use FILE as program to be debugged.\n\ |
724 | It is read for its symbols, for getting the contents of pure memory,\n\ |
725 | and it is the program executed when you use the `run' command.\n\ |
726 | If FILE cannot be found as specified, your execution directory path\n\ |
727 | ($PATH) is searched for a command of that name.\n\ |
728 | No arg means to have no executable file and no symbols.", &cmdlist); |
729 | set_cmd_completer (c, filename_completer); |
730 | } |
731 | |
732 | c = add_cmd ("exec-file", class_files, exec_file_command, |
733 | "Use FILE as program for getting contents of pure memory.\n\ |
734 | If FILE cannot be found as specified, your execution directory path\n\ |
735 | is searched for a command of that name.\n\ |
736 | No arg means have no executable file.", &cmdlist); |
737 | set_cmd_completer (c, filename_completer); |
738 | |
739 | add_com ("section", class_files, set_section_command, |
740 | "Change the base address of section SECTION of the exec file to ADDR.\n\ |
741 | This can be used if the exec file does not contain section addresses,\n\ |
742 | (such as in the a.out format), or when the addresses specified in the\n\ |
743 | file itself are wrong. Each section must be changed separately. The\n\ |
744 | ``info files'' command lists all the sections and their addresses."); |
745 | |
746 | deprecated_add_show_from_set |
747 | (add_set_cmd ("write", class_support, var_boolean, (char *) &write_files, |
748 | "Set writing into executable and core files.", |
749 | &setlist), |
750 | &showlist); |
751 | |
752 | add_target (&exec_ops); |
753 | } |
754 | |
755 | static char * |
756 | exec_make_note_section (bfd *obfd, int *note_size) |
757 | { |
758 | error ("Can't create a corefile"); |
759 | } |