gdb/exec.c

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