gdb/exec.c

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