Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / exec.c
1 /* Work with executable files, for GDB. 
2
3    Copyright (C) 1988-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 "frame.h"
22 #include "inferior.h"
23 #include "target.h"
24 #include "gdbcmd.h"
25 #include "language.h"
26 #include "filenames.h"
27 #include "symfile.h"
28 #include "objfiles.h"
29 #include "completer.h"
30 #include "value.h"
31 #include "exec.h"
32 #include "observer.h"
33 #include "arch-utils.h"
34 #include "gdbthread.h"
35 #include "progspace.h"
36 #include "gdb_bfd.h"
37
38 #include <fcntl.h>
39 #include "readline/readline.h"
40 #include "gdb_string.h"
41
42 #include "gdbcore.h"
43
44 #include <ctype.h>
45 #include "gdb_stat.h"
46
47 #include "xcoffsolib.h"
48
49 struct vmap *map_vmap (bfd *, bfd *);
50
51 void (*deprecated_file_changed_hook) (char *);
52
53 /* Prototypes for local functions */
54
55 static void file_command (char *, int);
56
57 static void set_section_command (char *, int);
58
59 static void exec_files_info (struct target_ops *);
60
61 static void init_exec_ops (void);
62
63 void _initialize_exec (void);
64
65 /* The target vector for executable files.  */
66
67 struct target_ops exec_ops;
68
69 /* True if the exec target is pushed on the stack.  */
70 static int using_exec_ops;
71
72 /* Whether to open exec and core files read-only or read-write.  */
73
74 int write_files = 0;
75 static void
76 show_write_files (struct ui_file *file, int from_tty,
77                   struct cmd_list_element *c, const char *value)
78 {
79   fprintf_filtered (file, _("Writing into executable and core files is %s.\n"),
80                     value);
81 }
82
83
84 struct vmap *vmap;
85
86 static void
87 exec_open (char *args, int from_tty)
88 {
89   target_preopen (from_tty);
90   exec_file_attach (args, from_tty);
91 }
92
93 /* Close and clear exec_bfd.  If we end up with no target sections to
94    read memory from, this unpushes the exec_ops target.  */
95
96 void
97 exec_close (void)
98 {
99   if (exec_bfd)
100     {
101       bfd *abfd = exec_bfd;
102
103       gdb_bfd_unref (abfd);
104
105       /* Removing target sections may close the exec_ops target.
106          Clear exec_bfd before doing so to prevent recursion.  */
107       exec_bfd = NULL;
108       exec_bfd_mtime = 0;
109
110       remove_target_sections (&exec_bfd, abfd);
111
112       xfree (exec_filename);
113       exec_filename = NULL;
114     }
115 }
116
117 /* This is the target_close implementation.  Clears all target
118    sections and closes all executable bfds from all program spaces.  */
119
120 static void
121 exec_close_1 (int quitting)
122 {
123   struct vmap *vp, *nxt;
124
125   using_exec_ops = 0;
126
127   for (nxt = vmap; nxt != NULL;)
128     {
129       vp = nxt;
130       nxt = vp->nxt;
131
132       if (vp->objfile)
133         free_objfile (vp->objfile);
134
135       gdb_bfd_unref (vp->bfd);
136
137       xfree (vp);
138     }
139
140   vmap = NULL;
141
142   {
143     struct program_space *ss;
144     struct cleanup *old_chain;
145
146     old_chain = save_current_program_space ();
147     ALL_PSPACES (ss)
148     {
149       set_current_program_space (ss);
150
151       /* Delete all target sections.  */
152       resize_section_table
153         (current_target_sections,
154          -resize_section_table (current_target_sections, 0));
155
156       exec_close ();
157     }
158
159     do_cleanups (old_chain);
160   }
161 }
162
163 void
164 exec_file_clear (int from_tty)
165 {
166   /* Remove exec file.  */
167   exec_close ();
168
169   if (from_tty)
170     printf_unfiltered (_("No executable file now.\n"));
171 }
172
173 /* Set FILENAME as the new exec file.
174
175    This function is intended to be behave essentially the same
176    as exec_file_command, except that the latter will detect when
177    a target is being debugged, and will ask the user whether it
178    should be shut down first.  (If the answer is "no", then the
179    new file is ignored.)
180
181    This file is used by exec_file_command, to do the work of opening
182    and processing the exec file after any prompting has happened.
183
184    And, it is used by child_attach, when the attach command was
185    given a pid but not a exec pathname, and the attach command could
186    figure out the pathname from the pid.  (In this case, we shouldn't
187    ask the user whether the current target should be shut down --
188    we're supplying the exec pathname late for good reason.)  */
189
190 void
191 exec_file_attach (char *filename, int from_tty)
192 {
193   /* Remove any previous exec file.  */
194   exec_close ();
195
196   /* Now open and digest the file the user requested, if any.  */
197
198   if (!filename)
199     {
200       if (from_tty)
201         printf_unfiltered (_("No executable file now.\n"));
202
203       set_gdbarch_from_file (NULL);
204     }
205   else
206     {
207       struct cleanup *cleanups;
208       char *scratch_pathname, *canonical_pathname;
209       int scratch_chan;
210       struct target_section *sections = NULL, *sections_end = NULL;
211       char **matching;
212
213       scratch_chan = openp (getenv ("PATH"),
214                             OPF_TRY_CWD_FIRST | OPF_DISABLE_REALPATH, filename,
215                    write_files ? O_RDWR | O_BINARY : O_RDONLY | O_BINARY,
216                             &scratch_pathname);
217 #if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
218       if (scratch_chan < 0)
219         {
220           char *exename = alloca (strlen (filename) + 5);
221
222           strcat (strcpy (exename, filename), ".exe");
223           scratch_chan = openp (getenv ("PATH"),
224                                 OPF_TRY_CWD_FIRST | OPF_DISABLE_REALPATH,
225                                 exename,
226              write_files ? O_RDWR | O_BINARY : O_RDONLY | O_BINARY,
227              &scratch_pathname);
228         }
229 #endif
230       if (scratch_chan < 0)
231         perror_with_name (filename);
232
233       cleanups = make_cleanup (xfree, scratch_pathname);
234
235       /* gdb_bfd_open (and its variants) prefers canonicalized pathname for
236          better BFD caching.  */
237       canonical_pathname = gdb_realpath (scratch_pathname);
238       make_cleanup (xfree, canonical_pathname);
239
240       if (write_files)
241         exec_bfd = gdb_bfd_fopen (canonical_pathname, gnutarget,
242                                   FOPEN_RUB, scratch_chan);
243       else
244         exec_bfd = gdb_bfd_open (canonical_pathname, gnutarget, scratch_chan);
245
246       if (!exec_bfd)
247         {
248           error (_("\"%s\": could not open as an executable file: %s"),
249                  scratch_pathname, bfd_errmsg (bfd_get_error ()));
250         }
251
252       gdb_assert (exec_filename == NULL);
253       exec_filename = xstrdup (scratch_pathname);
254
255       if (!bfd_check_format_matches (exec_bfd, bfd_object, &matching))
256         {
257           /* Make sure to close exec_bfd, or else "run" might try to use
258              it.  */
259           exec_close ();
260           error (_("\"%s\": not in executable format: %s"),
261                  scratch_pathname,
262                  gdb_bfd_errmsg (bfd_get_error (), matching));
263         }
264
265       /* FIXME - This should only be run for RS6000, but the ifdef is a poor
266          way to accomplish.  */
267 #ifdef DEPRECATED_IBM6000_TARGET
268       /* Setup initial vmap.  */
269
270       map_vmap (exec_bfd, 0);
271       if (vmap == NULL)
272         {
273           /* Make sure to close exec_bfd, or else "run" might try to use
274              it.  */
275           exec_close ();
276           error (_("\"%s\": can't find the file sections: %s"),
277                  scratch_pathname, bfd_errmsg (bfd_get_error ()));
278         }
279 #endif /* DEPRECATED_IBM6000_TARGET */
280
281       if (build_section_table (exec_bfd, &sections, &sections_end))
282         {
283           /* Make sure to close exec_bfd, or else "run" might try to use
284              it.  */
285           exec_close ();
286           error (_("\"%s\": can't find the file sections: %s"),
287                  scratch_pathname, bfd_errmsg (bfd_get_error ()));
288         }
289
290       exec_bfd_mtime = bfd_get_mtime (exec_bfd);
291
292       validate_files ();
293
294       set_gdbarch_from_file (exec_bfd);
295
296       /* Add the executable's sections to the current address spaces'
297          list of sections.  This possibly pushes the exec_ops
298          target.  */
299       add_target_sections (&exec_bfd, sections, sections_end);
300       xfree (sections);
301
302       /* Tell display code (if any) about the changed file name.  */
303       if (deprecated_exec_file_display_hook)
304         (*deprecated_exec_file_display_hook) (filename);
305
306       do_cleanups (cleanups);
307     }
308   bfd_cache_close_all ();
309   observer_notify_executable_changed ();
310 }
311
312 /*  Process the first arg in ARGS as the new exec file.
313
314    Note that we have to explicitly ignore additional args, since we can
315    be called from file_command(), which also calls symbol_file_command()
316    which can take multiple args.
317    
318    If ARGS is NULL, we just want to close the exec file.  */
319
320 static void
321 exec_file_command (char *args, int from_tty)
322 {
323   char **argv;
324   char *filename;
325
326   if (from_tty && target_has_execution
327       && !query (_("A program is being debugged already.\n"
328                    "Are you sure you want to change the file? ")))
329     error (_("File not changed."));
330
331   if (args)
332     {
333       struct cleanup *cleanups;
334
335       /* Scan through the args and pick up the first non option arg
336          as the filename.  */
337
338       argv = gdb_buildargv (args);
339       cleanups = make_cleanup_freeargv (argv);
340
341       for (; (*argv != NULL) && (**argv == '-'); argv++)
342         {;
343         }
344       if (*argv == NULL)
345         error (_("No executable file name was specified"));
346
347       filename = tilde_expand (*argv);
348       make_cleanup (xfree, filename);
349       exec_file_attach (filename, from_tty);
350
351       do_cleanups (cleanups);
352     }
353   else
354     exec_file_attach (NULL, from_tty);
355 }
356
357 /* Set both the exec file and the symbol file, in one command.
358    What a novelty.  Why did GDB go through four major releases before this
359    command was added?  */
360
361 static void
362 file_command (char *arg, int from_tty)
363 {
364   /* FIXME, if we lose on reading the symbol file, we should revert
365      the exec file, but that's rough.  */
366   exec_file_command (arg, from_tty);
367   symbol_file_command (arg, from_tty);
368   if (deprecated_file_changed_hook)
369     deprecated_file_changed_hook (arg);
370 }
371 \f
372
373 /* Locate all mappable sections of a BFD file.
374    table_pp_char is a char * to get it through bfd_map_over_sections;
375    we cast it back to its proper type.  */
376
377 static void
378 add_to_section_table (bfd *abfd, struct bfd_section *asect,
379                       void *table_pp_char)
380 {
381   struct target_section **table_pp = (struct target_section **) table_pp_char;
382   flagword aflag;
383
384   /* Check the section flags, but do not discard zero-length sections, since
385      some symbols may still be attached to this section.  For instance, we
386      encountered on sparc-solaris 2.10 a shared library with an empty .bss
387      section to which a symbol named "_end" was attached.  The address
388      of this symbol still needs to be relocated.  */
389   aflag = bfd_get_section_flags (abfd, asect);
390   if (!(aflag & SEC_ALLOC))
391     return;
392
393   (*table_pp)->key = NULL;
394   (*table_pp)->bfd = abfd;
395   (*table_pp)->the_bfd_section = asect;
396   (*table_pp)->addr = bfd_section_vma (abfd, asect);
397   (*table_pp)->endaddr = (*table_pp)->addr + bfd_section_size (abfd, asect);
398   (*table_pp)++;
399 }
400
401 int
402 resize_section_table (struct target_section_table *table, int num_added)
403 {
404   int old_count;
405   int new_count;
406
407   old_count = table->sections_end - table->sections;
408
409   new_count = num_added + old_count;
410
411   if (new_count)
412     {
413       table->sections = xrealloc (table->sections,
414                                   sizeof (struct target_section) * new_count);
415       table->sections_end = table->sections + new_count;
416     }
417   else
418     {
419       xfree (table->sections);
420       table->sections = table->sections_end = NULL;
421     }
422
423   return old_count;
424 }
425
426 /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
427    Returns 0 if OK, 1 on error.  */
428
429 int
430 build_section_table (struct bfd *some_bfd, struct target_section **start,
431                      struct target_section **end)
432 {
433   unsigned count;
434
435   count = bfd_count_sections (some_bfd);
436   if (*start)
437     xfree (* start);
438   *start = (struct target_section *) xmalloc (count * sizeof (**start));
439   *end = *start;
440   bfd_map_over_sections (some_bfd, add_to_section_table, (char *) end);
441   if (*end > *start + count)
442     internal_error (__FILE__, __LINE__,
443                     _("failed internal consistency check"));
444   /* We could realloc the table, but it probably loses for most files.  */
445   return 0;
446 }
447
448 /* Add the sections array defined by [SECTIONS..SECTIONS_END[ to the
449    current set of target sections.  */
450
451 void
452 add_target_sections (void *key,
453                      struct target_section *sections,
454                      struct target_section *sections_end)
455 {
456   int count;
457   struct target_section_table *table = current_target_sections;
458
459   count = sections_end - sections;
460
461   if (count > 0)
462     {
463       int space = resize_section_table (table, count);
464       int i;
465
466       for (i = 0; i < count; ++i)
467         {
468           table->sections[space + i] = sections[i];
469           table->sections[space + i].key = key;
470         }
471
472       /* If these are the first file sections we can provide memory
473          from, push the file_stratum target.  */
474       if (!using_exec_ops)
475         {
476           using_exec_ops = 1;
477           push_target (&exec_ops);
478         }
479     }
480 }
481
482 /* Remove all target sections taken from ABFD.  */
483
484 void
485 remove_target_sections (void *key, bfd *abfd)
486 {
487   struct target_section *src, *dest;
488   struct target_section_table *table = current_target_sections;
489
490   dest = table->sections;
491   for (src = table->sections; src < table->sections_end; src++)
492     if (src->key != key || src->bfd != abfd)
493       {
494         /* Keep this section.  */
495         if (dest < src)
496           *dest = *src;
497         dest++;
498       }
499
500   /* If we've dropped any sections, resize the section table.  */
501   if (dest < src)
502     {
503       int old_count;
504
505       old_count = resize_section_table (table, dest - src);
506
507       /* If we don't have any more sections to read memory from,
508          remove the file_stratum target from the stack.  */
509       if (old_count + (dest - src) == 0)
510         {
511           struct program_space *pspace;
512
513           ALL_PSPACES (pspace)
514             if (pspace->target_sections.sections
515                 != pspace->target_sections.sections_end)
516               return;
517
518           unpush_target (&exec_ops);
519         }
520     }
521 }
522
523 \f
524 static void
525 bfdsec_to_vmap (struct bfd *abfd, struct bfd_section *sect, void *arg3)
526 {
527   struct vmap_and_bfd *vmap_bfd = (struct vmap_and_bfd *) arg3;
528   struct vmap *vp;
529
530   vp = vmap_bfd->pvmap;
531
532   if ((bfd_get_section_flags (abfd, sect) & SEC_LOAD) == 0)
533     return;
534
535   if (strcmp (bfd_section_name (abfd, sect), ".text") == 0)
536     {
537       vp->tstart = bfd_section_vma (abfd, sect);
538       vp->tend = vp->tstart + bfd_section_size (abfd, sect);
539       vp->tvma = bfd_section_vma (abfd, sect);
540       vp->toffs = sect->filepos;
541     }
542   else if (strcmp (bfd_section_name (abfd, sect), ".data") == 0)
543     {
544       vp->dstart = bfd_section_vma (abfd, sect);
545       vp->dend = vp->dstart + bfd_section_size (abfd, sect);
546       vp->dvma = bfd_section_vma (abfd, sect);
547     }
548   /* Silently ignore other types of sections.  (FIXME?)  */
549 }
550
551 /* Make a vmap for ABFD which might be a member of the archive ARCH.
552    Return the new vmap.  */
553
554 struct vmap *
555 map_vmap (bfd *abfd, bfd *arch)
556 {
557   struct vmap_and_bfd vmap_bfd;
558   struct vmap *vp, **vpp;
559
560   vp = (struct vmap *) xmalloc (sizeof (*vp));
561   memset ((char *) vp, '\0', sizeof (*vp));
562   vp->nxt = 0;
563   vp->bfd = abfd;
564   gdb_bfd_ref (abfd);
565   vp->name = bfd_get_filename (arch ? arch : abfd);
566   vp->member = arch ? bfd_get_filename (abfd) : "";
567
568   vmap_bfd.pbfd = arch;
569   vmap_bfd.pvmap = vp;
570   bfd_map_over_sections (abfd, bfdsec_to_vmap, &vmap_bfd);
571
572   /* Find the end of the list and append.  */
573   for (vpp = &vmap; *vpp; vpp = &(*vpp)->nxt)
574     ;
575   *vpp = vp;
576
577   return vp;
578 }
579 \f
580
581 VEC(mem_range_s) *
582 section_table_available_memory (VEC(mem_range_s) *memory,
583                                 CORE_ADDR memaddr, ULONGEST len,
584                                 struct target_section *sections,
585                                 struct target_section *sections_end)
586 {
587   struct target_section *p;
588
589   for (p = sections; p < sections_end; p++)
590     {
591       if ((bfd_get_section_flags (p->bfd, p->the_bfd_section)
592            & SEC_READONLY) == 0)
593         continue;
594
595       /* Copy the meta-data, adjusted.  */
596       if (mem_ranges_overlap (p->addr, p->endaddr - p->addr, memaddr, len))
597         {
598           ULONGEST lo1, hi1, lo2, hi2;
599           struct mem_range *r;
600
601           lo1 = memaddr;
602           hi1 = memaddr + len;
603
604           lo2 = p->addr;
605           hi2 = p->endaddr;
606
607           r = VEC_safe_push (mem_range_s, memory, NULL);
608
609           r->start = max (lo1, lo2);
610           r->length = min (hi1, hi2) - r->start;
611         }
612     }
613
614   return memory;
615 }
616
617 int
618 section_table_xfer_memory_partial (gdb_byte *readbuf, const gdb_byte *writebuf,
619                                    ULONGEST offset, LONGEST len,
620                                    struct target_section *sections,
621                                    struct target_section *sections_end,
622                                    const char *section_name)
623 {
624   int res;
625   struct target_section *p;
626   ULONGEST memaddr = offset;
627   ULONGEST memend = memaddr + len;
628
629   if (len <= 0)
630     internal_error (__FILE__, __LINE__,
631                     _("failed internal consistency check"));
632
633   for (p = sections; p < sections_end; p++)
634     {
635       if (section_name && strcmp (section_name, p->the_bfd_section->name) != 0)
636         continue;               /* not the section we need.  */
637       if (memaddr >= p->addr)
638         {
639           if (memend <= p->endaddr)
640             {
641               /* Entire transfer is within this section.  */
642               if (writebuf)
643                 res = bfd_set_section_contents (p->bfd, p->the_bfd_section,
644                                                 writebuf, memaddr - p->addr,
645                                                 len);
646               else
647                 res = bfd_get_section_contents (p->bfd, p->the_bfd_section,
648                                                 readbuf, memaddr - p->addr,
649                                                 len);
650               return (res != 0) ? len : 0;
651             }
652           else if (memaddr >= p->endaddr)
653             {
654               /* This section ends before the transfer starts.  */
655               continue;
656             }
657           else
658             {
659               /* This section overlaps the transfer.  Just do half.  */
660               len = p->endaddr - memaddr;
661               if (writebuf)
662                 res = bfd_set_section_contents (p->bfd, p->the_bfd_section,
663                                                 writebuf, memaddr - p->addr,
664                                                 len);
665               else
666                 res = bfd_get_section_contents (p->bfd, p->the_bfd_section,
667                                                 readbuf, memaddr - p->addr,
668                                                 len);
669               return (res != 0) ? len : 0;
670             }
671         }
672     }
673
674   return 0;                     /* We can't help.  */
675 }
676
677 static struct target_section_table *
678 exec_get_section_table (struct target_ops *ops)
679 {
680   return current_target_sections;
681 }
682
683 static LONGEST
684 exec_xfer_partial (struct target_ops *ops, enum target_object object,
685                    const char *annex, gdb_byte *readbuf,
686                    const gdb_byte *writebuf,
687                    ULONGEST offset, LONGEST len)
688 {
689   struct target_section_table *table = target_get_section_table (ops);
690
691   if (object == TARGET_OBJECT_MEMORY)
692     return section_table_xfer_memory_partial (readbuf, writebuf,
693                                               offset, len,
694                                               table->sections,
695                                               table->sections_end,
696                                               NULL);
697   else
698     return -1;
699 }
700 \f
701
702 void
703 print_section_info (struct target_section_table *t, bfd *abfd)
704 {
705   struct gdbarch *gdbarch = gdbarch_from_bfd (abfd);
706   struct target_section *p;
707   /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64.  */
708   int wid = gdbarch_addr_bit (gdbarch) <= 32 ? 8 : 16;
709
710   printf_filtered ("\t`%s', ", bfd_get_filename (abfd));
711   wrap_here ("        ");
712   printf_filtered (_("file type %s.\n"), bfd_get_target (abfd));
713   if (abfd == exec_bfd)
714     {
715       /* gcc-3.4 does not like the initialization in
716          <p == t->sections_end>.  */
717       bfd_vma displacement = 0;
718       bfd_vma entry_point;
719
720       for (p = t->sections; p < t->sections_end; p++)
721         {
722           asection *asect = p->the_bfd_section;
723
724           if ((bfd_get_section_flags (abfd, asect) & (SEC_ALLOC | SEC_LOAD))
725               != (SEC_ALLOC | SEC_LOAD))
726             continue;
727
728           if (bfd_get_section_vma (abfd, asect) <= abfd->start_address
729               && abfd->start_address < (bfd_get_section_vma (abfd, asect)
730                                         + bfd_get_section_size (asect)))
731             {
732               displacement = p->addr - bfd_get_section_vma (abfd, asect);
733               break;
734             }
735         }
736       if (p == t->sections_end)
737         warning (_("Cannot find section for the entry point of %s."),
738                  bfd_get_filename (abfd));
739
740       entry_point = gdbarch_addr_bits_remove (gdbarch, 
741                                               bfd_get_start_address (abfd) 
742                                                 + displacement);
743       printf_filtered (_("\tEntry point: %s\n"),
744                        paddress (gdbarch, entry_point));
745     }
746   for (p = t->sections; p < t->sections_end; p++)
747     {
748       printf_filtered ("\t%s", hex_string_custom (p->addr, wid));
749       printf_filtered (" - %s", hex_string_custom (p->endaddr, wid));
750
751       /* FIXME: A format of "08l" is not wide enough for file offsets
752          larger than 4GB.  OTOH, making it "016l" isn't desirable either
753          since most output will then be much wider than necessary.  It
754          may make sense to test the size of the file and choose the
755          format string accordingly.  */
756       /* FIXME: i18n: Need to rewrite this sentence.  */
757       if (info_verbose)
758         printf_filtered (" @ %s",
759                          hex_string_custom (p->the_bfd_section->filepos, 8));
760       printf_filtered (" is %s", bfd_section_name (p->bfd,
761                                                    p->the_bfd_section));
762       if (p->bfd != abfd)
763         printf_filtered (" in %s", bfd_get_filename (p->bfd));
764       printf_filtered ("\n");
765     }
766 }
767
768 static void
769 exec_files_info (struct target_ops *t)
770 {
771   if (exec_bfd)
772     print_section_info (current_target_sections, exec_bfd);
773   else
774     puts_filtered (_("\t<no file loaded>\n"));
775
776   if (vmap)
777     {
778       int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
779       struct vmap *vp;
780
781       printf_unfiltered (_("\tMapping info for file `%s'.\n"), vmap->name);
782       printf_unfiltered ("\t  %*s   %*s   %*s   %*s %8.8s %s\n",
783                          addr_size * 2, "tstart",
784                          addr_size * 2, "tend",
785                          addr_size * 2, "dstart",
786                          addr_size * 2, "dend",
787                          "section",
788                          "file(member)");
789
790       for (vp = vmap; vp; vp = vp->nxt)
791         printf_unfiltered ("\t0x%s 0x%s 0x%s 0x%s %s%s%s%s\n",
792                            phex (vp->tstart, addr_size),
793                            phex (vp->tend, addr_size),
794                            phex (vp->dstart, addr_size),
795                            phex (vp->dend, addr_size),
796                            vp->name,
797                            *vp->member ? "(" : "", vp->member,
798                            *vp->member ? ")" : "");
799     }
800 }
801
802 static void
803 set_section_command (char *args, int from_tty)
804 {
805   struct target_section *p;
806   char *secname;
807   unsigned seclen;
808   unsigned long secaddr;
809   char secprint[100];
810   long offset;
811   struct target_section_table *table;
812
813   if (args == 0)
814     error (_("Must specify section name and its virtual address"));
815
816   /* Parse out section name.  */
817   for (secname = args; !isspace (*args); args++);
818   seclen = args - secname;
819
820   /* Parse out new virtual address.  */
821   secaddr = parse_and_eval_address (args);
822
823   table = current_target_sections;
824   for (p = table->sections; p < table->sections_end; p++)
825     {
826       if (!strncmp (secname, bfd_section_name (p->bfd,
827                                                p->the_bfd_section), seclen)
828           && bfd_section_name (p->bfd, p->the_bfd_section)[seclen] == '\0')
829         {
830           offset = secaddr - p->addr;
831           p->addr += offset;
832           p->endaddr += offset;
833           if (from_tty)
834             exec_files_info (&exec_ops);
835           return;
836         }
837     }
838   if (seclen >= sizeof (secprint))
839     seclen = sizeof (secprint) - 1;
840   strncpy (secprint, secname, seclen);
841   secprint[seclen] = '\0';
842   error (_("Section %s not found"), secprint);
843 }
844
845 /* If we can find a section in FILENAME with BFD index INDEX, adjust
846    it to ADDRESS.  */
847
848 void
849 exec_set_section_address (const char *filename, int index, CORE_ADDR address)
850 {
851   struct target_section *p;
852   struct target_section_table *table;
853
854   table = current_target_sections;
855   for (p = table->sections; p < table->sections_end; p++)
856     {
857       if (filename_cmp (filename, p->bfd->filename) == 0
858           && index == p->the_bfd_section->index)
859         {
860           p->endaddr += address - p->addr;
861           p->addr = address;
862         }
863     }
864 }
865
866 /* If mourn is being called in all the right places, this could be say
867    `gdb internal error' (since generic_mourn calls
868    breakpoint_init_inferior).  */
869
870 static int
871 ignore (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
872 {
873   return 0;
874 }
875
876 static int
877 exec_has_memory (struct target_ops *ops)
878 {
879   /* We can provide memory if we have any file/target sections to read
880      from.  */
881   return (current_target_sections->sections
882           != current_target_sections->sections_end);
883 }
884
885 /* Find mapped memory.  */
886
887 extern void
888 exec_set_find_memory_regions (int (*func) (find_memory_region_ftype, void *))
889 {
890   exec_ops.to_find_memory_regions = func;
891 }
892
893 static char *exec_make_note_section (bfd *, int *);
894
895 /* Fill in the exec file target vector.  Very few entries need to be
896    defined.  */
897
898 static void
899 init_exec_ops (void)
900 {
901   exec_ops.to_shortname = "exec";
902   exec_ops.to_longname = "Local exec file";
903   exec_ops.to_doc = "Use an executable file as a target.\n\
904 Specify the filename of the executable file.";
905   exec_ops.to_open = exec_open;
906   exec_ops.to_close = exec_close_1;
907   exec_ops.to_attach = find_default_attach;
908   exec_ops.to_xfer_partial = exec_xfer_partial;
909   exec_ops.to_get_section_table = exec_get_section_table;
910   exec_ops.to_files_info = exec_files_info;
911   exec_ops.to_insert_breakpoint = ignore;
912   exec_ops.to_remove_breakpoint = ignore;
913   exec_ops.to_create_inferior = find_default_create_inferior;
914   exec_ops.to_stratum = file_stratum;
915   exec_ops.to_has_memory = exec_has_memory;
916   exec_ops.to_make_corefile_notes = exec_make_note_section;
917   exec_ops.to_magic = OPS_MAGIC;
918 }
919
920 void
921 _initialize_exec (void)
922 {
923   struct cmd_list_element *c;
924
925   init_exec_ops ();
926
927   if (!dbx_commands)
928     {
929       c = add_cmd ("file", class_files, file_command, _("\
930 Use FILE as program to be debugged.\n\
931 It is read for its symbols, for getting the contents of pure memory,\n\
932 and it is the program executed when you use the `run' command.\n\
933 If FILE cannot be found as specified, your execution directory path\n\
934 ($PATH) is searched for a command of that name.\n\
935 No arg means to have no executable file and no symbols."), &cmdlist);
936       set_cmd_completer (c, filename_completer);
937     }
938
939   c = add_cmd ("exec-file", class_files, exec_file_command, _("\
940 Use FILE as program for getting contents of pure memory.\n\
941 If FILE cannot be found as specified, your execution directory path\n\
942 is searched for a command of that name.\n\
943 No arg means have no executable file."), &cmdlist);
944   set_cmd_completer (c, filename_completer);
945
946   add_com ("section", class_files, set_section_command, _("\
947 Change the base address of section SECTION of the exec file to ADDR.\n\
948 This can be used if the exec file does not contain section addresses,\n\
949 (such as in the a.out format), or when the addresses specified in the\n\
950 file itself are wrong.  Each section must be changed separately.  The\n\
951 ``info files'' command lists all the sections and their addresses."));
952
953   add_setshow_boolean_cmd ("write", class_support, &write_files, _("\
954 Set writing into executable and core files."), _("\
955 Show writing into executable and core files."), NULL,
956                            NULL,
957                            show_write_files,
958                            &setlist, &showlist);
959
960   add_target (&exec_ops);
961 }
962
963 static char *
964 exec_make_note_section (bfd *obfd, int *note_size)
965 {
966   error (_("Can't create a corefile"));
967 }