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 enum target_xfer_status
 534 exec_read_partial_read_only (gdb_byte *readbuf, ULONGEST offset,
 535                              ULONGEST len, ULONGEST *xfered_len)
 536 {
 537   /* It's unduly pedantic to refuse to look at the executable for
 538      read-only pieces; so do the equivalent of readonly regions aka
 539      QTro packet.  */
 540   if (exec_bfd != NULL)
 541     {
 542       asection *s;
 543       bfd_size_type size;
 544       bfd_vma vma;
 545
 546       for (s = exec_bfd->sections; s; s = s->next)
 547         {
 548           if ((s->flags & SEC_LOAD) == 0
 549               || (s->flags & SEC_READONLY) == 0)
 550             continue;
 551
 552           vma = s->vma;
 553           size = bfd_get_section_size (s);
 554           if (vma <= offset && offset < (vma + size))
 555             {
 556               ULONGEST amt;
 557
 558               amt = (vma + size) - offset;
 559               if (amt > len)
 560                 amt = len;
 561
 562               amt = bfd_get_section_contents (exec_bfd, s,
 563                                               readbuf, offset - vma, amt);
 564
 565               if (amt == 0)
 566                 return TARGET_XFER_EOF;
 567               else
 568                 {
 569                   *xfered_len = amt;
 570                   return TARGET_XFER_OK;
 571                 }
 572             }
 573         }
 574     }
 575
 576   /* Indicate failure to find the requested memory block.  */
 577   return TARGET_XFER_E_IO;
 578 }
 579
 580 /* Appends all read-only memory ranges found in the target section
 581    table defined by SECTIONS and SECTIONS_END, starting at (and
 582    intersected with) MEMADDR for LEN bytes.  Returns the augmented
 583    VEC.  */
 584
 585 static VEC(mem_range_s) *
 586 section_table_available_memory (VEC(mem_range_s) *memory,
 587                                 CORE_ADDR memaddr, ULONGEST len,
 588                                 struct target_section *sections,
 589                                 struct target_section *sections_end)
 590 {
 591   struct target_section *p;
 592
 593   for (p = sections; p < sections_end; p++)
 594     {
 595       if ((bfd_get_section_flags (p->the_bfd_section->owner,
 596                                   p->the_bfd_section)
 597            & SEC_READONLY) == 0)
 598         continue;
 599
 600       /* Copy the meta-data, adjusted.  */
 601       if (mem_ranges_overlap (p->addr, p->endaddr - p->addr, memaddr, len))
 602         {
 603           ULONGEST lo1, hi1, lo2, hi2;
 604           struct mem_range *r;
 605
 606           lo1 = memaddr;
 607           hi1 = memaddr + len;
 608
 609           lo2 = p->addr;
 610           hi2 = p->endaddr;
 611
 612           r = VEC_safe_push (mem_range_s, memory, NULL);
 613
 614           r->start = max (lo1, lo2);
 615           r->length = min (hi1, hi2) - r->start;
 616         }
 617     }
 618
 619   return memory;
 620 }
 621
 622 enum target_xfer_status
 623 section_table_read_available_memory (gdb_byte *readbuf, ULONGEST offset,
 624                                      ULONGEST len, ULONGEST *xfered_len)
 625 {
 626   VEC(mem_range_s) *available_memory = NULL;
 627   struct target_section_table *table;
 628   struct cleanup *old_chain;
 629   mem_range_s *r;
 630   int i;
 631
 632   table = target_get_section_table (&exec_ops);
 633   available_memory = section_table_available_memory (available_memory,
 634                                                      offset, len,
 635                                                      table->sections,
 636                                                      table->sections_end);
 637
 638   old_chain = make_cleanup (VEC_cleanup(mem_range_s),
 639                             &available_memory);
 640
 641   normalize_mem_ranges (available_memory);
 642
 643   for (i = 0;
 644        VEC_iterate (mem_range_s, available_memory, i, r);
 645        i++)
 646     {
 647       if (mem_ranges_overlap (r->start, r->length, offset, len))
 648         {
 649           CORE_ADDR end;
 650           enum target_xfer_status status;
 651
 652           /* Get the intersection window.  */
 653           end = min (offset + len, r->start + r->length);
 654
 655           gdb_assert (end - offset <= len);
 656
 657           if (offset >= r->start)
 658             status = exec_read_partial_read_only (readbuf, offset,
 659                                                   end - offset,
 660                                                   xfered_len);
 661           else
 662             {
 663               *xfered_len = r->start - offset;
 664               status = TARGET_XFER_E_UNAVAILABLE;
 665             }
 666           do_cleanups (old_chain);
 667           return status;
 668         }
 669     }
 670   do_cleanups (old_chain);
 671
 672   *xfered_len = len;
 673   return TARGET_XFER_E_UNAVAILABLE;
 674 }
 675
 676 enum target_xfer_status
 677 section_table_xfer_memory_partial (gdb_byte *readbuf, const gdb_byte *writebuf,
 678                                    ULONGEST offset, ULONGEST len,
 679                                    ULONGEST *xfered_len,
 680                                    struct target_section *sections,
 681                                    struct target_section *sections_end,
 682                                    const char *section_name)
 683 {
 684   int res;
 685   struct target_section *p;
 686   ULONGEST memaddr = offset;
 687   ULONGEST memend = memaddr + len;
 688
 689   if (len == 0)
 690     internal_error (__FILE__, __LINE__,
 691                     _("failed internal consistency check"));
 692
 693   for (p = sections; p < sections_end; p++)
 694     {
 695       struct bfd_section *asect = p->the_bfd_section;
 696       bfd *abfd = asect->owner;
 697
 698       if (section_name && strcmp (section_name, asect->name) != 0)
 699         continue;               /* not the section we need.  */
 700       if (memaddr >= p->addr)
 701         {
 702           if (memend <= p->endaddr)
 703             {
 704               /* Entire transfer is within this section.  */
 705               if (writebuf)
 706                 res = bfd_set_section_contents (abfd, asect,
 707                                                 writebuf, memaddr - p->addr,
 708                                                 len);
 709               else
 710                 res = bfd_get_section_contents (abfd, asect,
 711                                                 readbuf, memaddr - p->addr,
 712                                                 len);
 713
 714               if (res != 0)
 715                 {
 716                   *xfered_len = len;
 717                   return TARGET_XFER_OK;
 718                 }
 719               else
 720                 return TARGET_XFER_EOF;
 721             }
 722           else if (memaddr >= p->endaddr)
 723             {
 724               /* This section ends before the transfer starts.  */
 725               continue;
 726             }
 727           else
 728             {
 729               /* This section overlaps the transfer.  Just do half.  */
 730               len = p->endaddr - memaddr;
 731               if (writebuf)
 732                 res = bfd_set_section_contents (abfd, asect,
 733                                                 writebuf, memaddr - p->addr,
 734                                                 len);
 735               else
 736                 res = bfd_get_section_contents (abfd, asect,
 737                                                 readbuf, memaddr - p->addr,
 738                                                 len);
 739               if (res != 0)
 740                 {
 741                   *xfered_len = len;
 742                   return TARGET_XFER_OK;
 743                 }
 744               else
 745                 return TARGET_XFER_EOF;
 746             }
 747         }
 748     }
 749
 750   return TARGET_XFER_EOF;               /* We can't help.  */
 751 }
 752
 753 static struct target_section_table *
 754 exec_get_section_table (struct target_ops *ops)
 755 {
 756   return current_target_sections;
 757 }
 758
 759 static enum target_xfer_status
 760 exec_xfer_partial (struct target_ops *ops, enum target_object object,
 761                    const char *annex, gdb_byte *readbuf,
 762                    const gdb_byte *writebuf,
 763                    ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
 764 {
 765   struct target_section_table *table = target_get_section_table (ops);
 766
 767   if (object == TARGET_OBJECT_MEMORY)
 768     return section_table_xfer_memory_partial (readbuf, writebuf,
 769                                               offset, len, xfered_len,
 770                                               table->sections,
 771                                               table->sections_end,
 772                                               NULL);
 773   else
 774     return TARGET_XFER_E_IO;
 775 }
 776 \f
 777
 778 void
 779 print_section_info (struct target_section_table *t, bfd *abfd)
 780 {
 781   struct gdbarch *gdbarch = gdbarch_from_bfd (abfd);
 782   struct target_section *p;
 783   /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64.  */
 784   int wid = gdbarch_addr_bit (gdbarch) <= 32 ? 8 : 16;
 785
 786   printf_filtered ("\t`%s', ", bfd_get_filename (abfd));
 787   wrap_here ("        ");
 788   printf_filtered (_("file type %s.\n"), bfd_get_target (abfd));
 789   if (abfd == exec_bfd)
 790     {
 791       /* gcc-3.4 does not like the initialization in
 792          <p == t->sections_end>.  */
 793       bfd_vma displacement = 0;
 794       bfd_vma entry_point;
 795
 796       for (p = t->sections; p < t->sections_end; p++)
 797         {
 798           struct bfd_section *psect = p->the_bfd_section;
 799           bfd *pbfd = psect->owner;
 800
 801           if ((bfd_get_section_flags (pbfd, psect) & (SEC_ALLOC | SEC_LOAD))
 802               != (SEC_ALLOC | SEC_LOAD))
 803             continue;
 804
 805           if (bfd_get_section_vma (pbfd, psect) <= abfd->start_address
 806               && abfd->start_address < (bfd_get_section_vma (pbfd, psect)
 807                                         + bfd_get_section_size (psect)))
 808             {
 809               displacement = p->addr - bfd_get_section_vma (pbfd, psect);
 810               break;
 811             }
 812         }
 813       if (p == t->sections_end)
 814         warning (_("Cannot find section for the entry point of %s."),
 815                  bfd_get_filename (abfd));
 816
 817       entry_point = gdbarch_addr_bits_remove (gdbarch,
 818                                               bfd_get_start_address (abfd)
 819                                                 + displacement);
 820       printf_filtered (_("\tEntry point: %s\n"),
 821                        paddress (gdbarch, entry_point));
 822     }
 823   for (p = t->sections; p < t->sections_end; p++)
 824     {
 825       struct bfd_section *psect = p->the_bfd_section;
 826       bfd *pbfd = psect->owner;
 827
 828       printf_filtered ("\t%s", hex_string_custom (p->addr, wid));
 829       printf_filtered (" - %s", hex_string_custom (p->endaddr, wid));
 830
 831       /* FIXME: A format of "08l" is not wide enough for file offsets
 832          larger than 4GB.  OTOH, making it "016l" isn't desirable either
 833          since most output will then be much wider than necessary.  It
 834          may make sense to test the size of the file and choose the
 835          format string accordingly.  */
 836       /* FIXME: i18n: Need to rewrite this sentence.  */
 837       if (info_verbose)
 838         printf_filtered (" @ %s",
 839                          hex_string_custom (psect->filepos, 8));
 840       printf_filtered (" is %s", bfd_section_name (pbfd, psect));
 841       if (pbfd != abfd)
 842         printf_filtered (" in %s", bfd_get_filename (pbfd));
 843       printf_filtered ("\n");
 844     }
 845 }
 846
 847 static void
 848 exec_files_info (struct target_ops *t)
 849 {
 850   if (exec_bfd)
 851     print_section_info (current_target_sections, exec_bfd);
 852   else
 853     puts_filtered (_("\t<no file loaded>\n"));
 854 }
 855
 856 static void
 857 set_section_command (char *args, int from_tty)
 858 {
 859   struct target_section *p;
 860   char *secname;
 861   unsigned seclen;
 862   unsigned long secaddr;
 863   char secprint[100];
 864   long offset;
 865   struct target_section_table *table;
 866
 867   if (args == 0)
 868     error (_("Must specify section name and its virtual address"));
 869
 870   /* Parse out section name.  */
 871   for (secname = args; !isspace (*args); args++);
 872   seclen = args - secname;
 873
 874   /* Parse out new virtual address.  */
 875   secaddr = parse_and_eval_address (args);
 876
 877   table = current_target_sections;
 878   for (p = table->sections; p < table->sections_end; p++)
 879     {
 880       if (!strncmp (secname, bfd_section_name (p->bfd,
 881                                                p->the_bfd_section), seclen)
 882           && bfd_section_name (p->bfd, p->the_bfd_section)[seclen] == '\0')
 883         {
 884           offset = secaddr - p->addr;
 885           p->addr += offset;
 886           p->endaddr += offset;
 887           if (from_tty)
 888             exec_files_info (&exec_ops);
 889           return;
 890         }
 891     }
 892   if (seclen >= sizeof (secprint))
 893     seclen = sizeof (secprint) - 1;
 894   strncpy (secprint, secname, seclen);
 895   secprint[seclen] = '\0';
 896   error (_("Section %s not found"), secprint);
 897 }
 898
 899 /* If we can find a section in FILENAME with BFD index INDEX, adjust
 900    it to ADDRESS.  */
 901
 902 void
 903 exec_set_section_address (const char *filename, int index, CORE_ADDR address)
 904 {
 905   struct target_section *p;
 906   struct target_section_table *table;
 907
 908   table = current_target_sections;
 909   for (p = table->sections; p < table->sections_end; p++)
 910     {
 911       if (filename_cmp (filename, p->the_bfd_section->owner->filename) == 0
 912           && index == p->the_bfd_section->index)
 913         {
 914           p->endaddr += address - p->addr;
 915           p->addr = address;
 916         }
 917     }
 918 }
 919
 920 /* If mourn is being called in all the right places, this could be say
 921    `gdb internal error' (since generic_mourn calls
 922    breakpoint_init_inferior).  */
 923
 924 static int
 925 ignore (struct target_ops *ops, struct gdbarch *gdbarch,
 926         struct bp_target_info *bp_tgt)
 927 {
 928   return 0;
 929 }
 930
 931 static int
 932 exec_has_memory (struct target_ops *ops)
 933 {
 934   /* We can provide memory if we have any file/target sections to read
 935      from.  */
 936   return (current_target_sections->sections
 937           != current_target_sections->sections_end);
 938 }
 939
 940 static char *exec_make_note_section (struct target_ops *self, bfd *, int *);
 941
 942 /* Fill in the exec file target vector.  Very few entries need to be
 943    defined.  */
 944
 945 static void
 946 init_exec_ops (void)
 947 {
 948   exec_ops.to_shortname = "exec";
 949   exec_ops.to_longname = "Local exec file";
 950   exec_ops.to_doc = "Use an executable file as a target.\n\
 951 Specify the filename of the executable file.";
 952   exec_ops.to_open = exec_open;
 953   exec_ops.to_close = exec_close_1;
 954   exec_ops.to_attach = find_default_attach;
 955   exec_ops.to_xfer_partial = exec_xfer_partial;
 956   exec_ops.to_get_section_table = exec_get_section_table;
 957   exec_ops.to_files_info = exec_files_info;
 958   exec_ops.to_insert_breakpoint = ignore;
 959   exec_ops.to_remove_breakpoint = ignore;
 960   exec_ops.to_create_inferior = find_default_create_inferior;
 961   exec_ops.to_stratum = file_stratum;
 962   exec_ops.to_has_memory = exec_has_memory;
 963   exec_ops.to_make_corefile_notes = exec_make_note_section;
 964   exec_ops.to_find_memory_regions = objfile_find_memory_regions;
 965   exec_ops.to_magic = OPS_MAGIC;
 966 }
 967
 968 void
 969 _initialize_exec (void)
 970 {
 971   struct cmd_list_element *c;
 972
 973   init_exec_ops ();
 974
 975   if (!dbx_commands)
 976     {
 977       c = add_cmd ("file", class_files, file_command, _("\
 978 Use FILE as program to be debugged.\n\
 979 It is read for its symbols, for getting the contents of pure memory,\n\
 980 and it is the program executed when you use the `run' command.\n\
 981 If FILE cannot be found as specified, your execution directory path\n\
 982 ($PATH) is searched for a command of that name.\n\
 983 No arg means to have no executable file and no symbols."), &cmdlist);
 984       set_cmd_completer (c, filename_completer);
 985     }
 986
 987   c = add_cmd ("exec-file", class_files, exec_file_command, _("\
 988 Use FILE as program for getting contents of pure memory.\n\
 989 If FILE cannot be found as specified, your execution directory path\n\
 990 is searched for a command of that name.\n\
 991 No arg means have no executable file."), &cmdlist);
 992   set_cmd_completer (c, filename_completer);
 993
 994   add_com ("section", class_files, set_section_command, _("\
 995 Change the base address of section SECTION of the exec file to ADDR.\n\
 996 This can be used if the exec file does not contain section addresses,\n\
 997 (such as in the a.out format), or when the addresses specified in the\n\
 998 file itself are wrong.  Each section must be changed separately.  The\n\
 999 ``info files'' command lists all the sections and their addresses."));
1000
1001   add_setshow_boolean_cmd ("write", class_support, &write_files, _("\
1002 Set writing into executable and core files."), _("\
1003 Show writing into executable and core files."), NULL,
1004                            NULL,
1005                            show_write_files,
1006                            &setlist, &showlist);
1007
1008   add_target_with_completer (&exec_ops, filename_completer);
1009 }
1010
1011 static char *
1012 exec_make_note_section (struct target_ops *self, bfd *obfd, int *note_size)
1013 {
1014   error (_("Can't create a corefile"));
1015 }