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