gdb/exec.c

   1 /* Work with executable files, for GDB.
   2
   3    Copyright (C) 1988-2017 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 "gdbcore.h"
  42
  43 #include <ctype.h>
  44 #include <sys/stat.h>
  45 #include "solist.h"
  46 #include <algorithm>
  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 static struct target_ops exec_ops;
  65
  66 /* Whether to open exec and core files read-only or read-write.  */
  67
  68 int write_files = 0;
  69 static void
  70 show_write_files (struct ui_file *file, int from_tty,
  71                   struct cmd_list_element *c, const char *value)
  72 {
  73   fprintf_filtered (file, _("Writing into executable and core files is %s.\n"),
  74                     value);
  75 }
  76
  77
  78 static void
  79 exec_open (const char *args, int from_tty)
  80 {
  81   target_preopen (from_tty);
  82   exec_file_attach (args, from_tty);
  83 }
  84
  85 /* Close and clear exec_bfd.  If we end up with no target sections to
  86    read memory from, this unpushes the exec_ops target.  */
  87
  88 void
  89 exec_close (void)
  90 {
  91   if (exec_bfd)
  92     {
  93       bfd *abfd = exec_bfd;
  94
  95       gdb_bfd_unref (abfd);
  96
  97       /* Removing target sections may close the exec_ops target.
  98          Clear exec_bfd before doing so to prevent recursion.  */
  99       exec_bfd = NULL;
 100       exec_bfd_mtime = 0;
 101
 102       remove_target_sections (&exec_bfd);
 103
 104       xfree (exec_filename);
 105       exec_filename = NULL;
 106     }
 107 }
 108
 109 /* This is the target_close implementation.  Clears all target
 110    sections and closes all executable bfds from all program spaces.  */
 111
 112 static void
 113 exec_close_1 (struct target_ops *self)
 114 {
 115   struct program_space *ss;
 116   scoped_restore_current_program_space restore_pspace;
 117
 118   ALL_PSPACES (ss)
 119     {
 120       set_current_program_space (ss);
 121       clear_section_table (current_target_sections);
 122       exec_close ();
 123     }
 124 }
 125
 126 void
 127 exec_file_clear (int from_tty)
 128 {
 129   /* Remove exec file.  */
 130   exec_close ();
 131
 132   if (from_tty)
 133     printf_unfiltered (_("No executable file now.\n"));
 134 }
 135
 136 /* See exec.h.  */
 137
 138 void
 139 try_open_exec_file (const char *exec_file_host, struct inferior *inf,
 140                     symfile_add_flags add_flags)
 141 {
 142   struct cleanup *old_chain;
 143   struct gdb_exception prev_err = exception_none;
 144
 145   old_chain = make_cleanup (free_current_contents, &prev_err.message);
 146
 147   /* exec_file_attach and symbol_file_add_main may throw an error if the file
 148      cannot be opened either locally or remotely.
 149
 150      This happens for example, when the file is first found in the local
 151      sysroot (above), and then disappears (a TOCTOU race), or when it doesn't
 152      exist in the target filesystem, or when the file does exist, but
 153      is not readable.
 154
 155      Even without a symbol file, the remote-based debugging session should
 156      continue normally instead of ending abruptly.  Hence we catch thrown
 157      errors/exceptions in the following code.  */
 158   TRY
 159     {
 160       /* We must do this step even if exec_file_host is NULL, so that
 161          exec_file_attach will clear state.  */
 162       exec_file_attach (exec_file_host, add_flags & SYMFILE_VERBOSE);
 163     }
 164   CATCH (err, RETURN_MASK_ERROR)
 165     {
 166       if (err.message != NULL)
 167         warning ("%s", err.message);
 168
 169       prev_err = err;
 170
 171       /* Save message so it doesn't get trashed by the catch below.  */
 172       if (err.message != NULL)
 173         prev_err.message = xstrdup (err.message);
 174     }
 175   END_CATCH
 176
 177   if (exec_file_host != NULL)
 178     {
 179       TRY
 180         {
 181           symbol_file_add_main (exec_file_host, add_flags);
 182         }
 183       CATCH (err, RETURN_MASK_ERROR)
 184         {
 185           if (!exception_print_same (prev_err, err))
 186             warning ("%s", err.message);
 187         }
 188       END_CATCH
 189     }
 190
 191   do_cleanups (old_chain);
 192 }
 193
 194 /* See gdbcore.h.  */
 195
 196 void
 197 exec_file_locate_attach (int pid, int defer_bp_reset, int from_tty)
 198 {
 199   char *exec_file_target, *exec_file_host;
 200   struct cleanup *old_chain;
 201   symfile_add_flags add_flags = 0;
 202
 203   /* Do nothing if we already have an executable filename.  */
 204   if (get_exec_file (0) != NULL)
 205     return;
 206
 207   /* Try to determine a filename from the process itself.  */
 208   exec_file_target = target_pid_to_exec_file (pid);
 209   if (exec_file_target == NULL)
 210     {
 211       warning (_("No executable has been specified and target does not "
 212                  "support\n"
 213                  "determining executable automatically.  "
 214                  "Try using the \"file\" command."));
 215       return;
 216     }
 217
 218   exec_file_host = exec_file_find (exec_file_target, NULL);
 219   old_chain = make_cleanup (xfree, exec_file_host);
 220
 221   if (defer_bp_reset)
 222     add_flags |= SYMFILE_DEFER_BP_RESET;
 223
 224   if (from_tty)
 225     add_flags |= SYMFILE_VERBOSE;
 226
 227   /* Attempt to open the exec file.  */
 228   try_open_exec_file (exec_file_host, current_inferior (), add_flags);
 229   do_cleanups (old_chain);
 230 }
 231
 232 /* Set FILENAME as the new exec file.
 233
 234    This function is intended to be behave essentially the same
 235    as exec_file_command, except that the latter will detect when
 236    a target is being debugged, and will ask the user whether it
 237    should be shut down first.  (If the answer is "no", then the
 238    new file is ignored.)
 239
 240    This file is used by exec_file_command, to do the work of opening
 241    and processing the exec file after any prompting has happened.
 242
 243    And, it is used by child_attach, when the attach command was
 244    given a pid but not a exec pathname, and the attach command could
 245    figure out the pathname from the pid.  (In this case, we shouldn't
 246    ask the user whether the current target should be shut down --
 247    we're supplying the exec pathname late for good reason.)  */
 248
 249 void
 250 exec_file_attach (const char *filename, int from_tty)
 251 {
 252   /* First, acquire a reference to the current exec_bfd.  We release
 253      this at the end of the function; but acquiring it now lets the
 254      BFD cache return it if this call refers to the same file.  */
 255   gdb_bfd_ref (exec_bfd);
 256   gdb_bfd_ref_ptr exec_bfd_holder (exec_bfd);
 257
 258   /* Remove any previous exec file.  */
 259   exec_close ();
 260
 261   /* Now open and digest the file the user requested, if any.  */
 262
 263   if (!filename)
 264     {
 265       if (from_tty)
 266         printf_unfiltered (_("No executable file now.\n"));
 267
 268       set_gdbarch_from_file (NULL);
 269     }
 270   else
 271     {
 272       int load_via_target = 0;
 273       const char *scratch_pathname, *canonical_pathname;
 274       int scratch_chan;
 275       struct target_section *sections = NULL, *sections_end = NULL;
 276       char **matching;
 277
 278       if (is_target_filename (filename))
 279         {
 280           if (target_filesystem_is_local ())
 281             filename += strlen (TARGET_SYSROOT_PREFIX);
 282           else
 283             load_via_target = 1;
 284         }
 285
 286       gdb::unique_xmalloc_ptr<char> canonical_storage, scratch_storage;
 287       if (load_via_target)
 288         {
 289           /* gdb_bfd_fopen does not support "target:" filenames.  */
 290           if (write_files)
 291             warning (_("writing into executable files is "
 292                        "not supported for %s sysroots"),
 293                      TARGET_SYSROOT_PREFIX);
 294
 295           scratch_pathname = filename;
 296           scratch_chan = -1;
 297           canonical_pathname = scratch_pathname;
 298         }
 299       else
 300         {
 301           char *temp_pathname;
 302
 303           scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST,
 304                                 filename, write_files ?
 305                                 O_RDWR | O_BINARY : O_RDONLY | O_BINARY,
 306                                 &temp_pathname);
 307 #if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
 308           if (scratch_chan < 0)
 309             {
 310               char *exename = (char *) alloca (strlen (filename) + 5);
 311
 312               strcat (strcpy (exename, filename), ".exe");
 313               scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST,
 314                                     exename, write_files ?
 315                                     O_RDWR | O_BINARY
 316                                     : O_RDONLY | O_BINARY,
 317                                     &temp_pathname);
 318             }
 319 #endif
 320           if (scratch_chan < 0)
 321             perror_with_name (filename);
 322
 323           scratch_storage.reset (temp_pathname);
 324           scratch_pathname = temp_pathname;
 325
 326           /* gdb_bfd_open (and its variants) prefers canonicalized
 327              pathname for better BFD caching.  */
 328           canonical_storage = gdb_realpath (scratch_pathname);
 329           canonical_pathname = canonical_storage.get ();
 330         }
 331
 332       gdb_bfd_ref_ptr temp;
 333       if (write_files && !load_via_target)
 334         temp = gdb_bfd_fopen (canonical_pathname, gnutarget,
 335                               FOPEN_RUB, scratch_chan);
 336       else
 337         temp = gdb_bfd_open (canonical_pathname, gnutarget, scratch_chan);
 338       exec_bfd = temp.release ();
 339
 340       if (!exec_bfd)
 341         {
 342           error (_("\"%s\": could not open as an executable file: %s."),
 343                  scratch_pathname, bfd_errmsg (bfd_get_error ()));
 344         }
 345
 346       /* gdb_realpath_keepfile resolves symlinks on the local
 347          filesystem and so cannot be used for "target:" files.  */
 348       gdb_assert (exec_filename == NULL);
 349       if (load_via_target)
 350         exec_filename = xstrdup (bfd_get_filename (exec_bfd));
 351       else
 352         exec_filename = gdb_realpath_keepfile (scratch_pathname).release ();
 353
 354       if (!bfd_check_format_matches (exec_bfd, bfd_object, &matching))
 355         {
 356           /* Make sure to close exec_bfd, or else "run" might try to use
 357              it.  */
 358           exec_close ();
 359           error (_("\"%s\": not in executable format: %s"),
 360                  scratch_pathname,
 361                  gdb_bfd_errmsg (bfd_get_error (), matching));
 362         }
 363
 364       if (build_section_table (exec_bfd, &sections, &sections_end))
 365         {
 366           /* Make sure to close exec_bfd, or else "run" might try to use
 367              it.  */
 368           exec_close ();
 369           error (_("\"%s\": can't find the file sections: %s"),
 370                  scratch_pathname, bfd_errmsg (bfd_get_error ()));
 371         }
 372
 373       exec_bfd_mtime = bfd_get_mtime (exec_bfd);
 374
 375       validate_files ();
 376
 377       set_gdbarch_from_file (exec_bfd);
 378
 379       /* Add the executable's sections to the current address spaces'
 380          list of sections.  This possibly pushes the exec_ops
 381          target.  */
 382       add_target_sections (&exec_bfd, sections, sections_end);
 383       xfree (sections);
 384
 385       /* Tell display code (if any) about the changed file name.  */
 386       if (deprecated_exec_file_display_hook)
 387         (*deprecated_exec_file_display_hook) (filename);
 388     }
 389
 390   bfd_cache_close_all ();
 391   observer_notify_executable_changed ();
 392 }
 393
 394 /*  Process the first arg in ARGS as the new exec file.
 395
 396    Note that we have to explicitly ignore additional args, since we can
 397    be called from file_command(), which also calls symbol_file_command()
 398    which can take multiple args.
 399
 400    If ARGS is NULL, we just want to close the exec file.  */
 401
 402 static void
 403 exec_file_command (char *args, int from_tty)
 404 {
 405   char *filename;
 406
 407   if (from_tty && target_has_execution
 408       && !query (_("A program is being debugged already.\n"
 409                    "Are you sure you want to change the file? ")))
 410     error (_("File not changed."));
 411
 412   if (args)
 413     {
 414       /* Scan through the args and pick up the first non option arg
 415          as the filename.  */
 416
 417       gdb_argv built_argv (args);
 418       char **argv = built_argv.get ();
 419
 420       for (; (*argv != NULL) && (**argv == '-'); argv++)
 421         {;
 422         }
 423       if (*argv == NULL)
 424         error (_("No executable file name was specified"));
 425
 426       gdb::unique_xmalloc_ptr<char> filename (tilde_expand (*argv));
 427       exec_file_attach (filename.get (), from_tty);
 428     }
 429   else
 430     exec_file_attach (NULL, from_tty);
 431 }
 432
 433 /* Set both the exec file and the symbol file, in one command.
 434    What a novelty.  Why did GDB go through four major releases before this
 435    command was added?  */
 436
 437 static void
 438 file_command (char *arg, int from_tty)
 439 {
 440   /* FIXME, if we lose on reading the symbol file, we should revert
 441      the exec file, but that's rough.  */
 442   exec_file_command (arg, from_tty);
 443   symbol_file_command (arg, from_tty);
 444   if (deprecated_file_changed_hook)
 445     deprecated_file_changed_hook (arg);
 446 }
 447 \f
 448
 449 /* Locate all mappable sections of a BFD file.
 450    table_pp_char is a char * to get it through bfd_map_over_sections;
 451    we cast it back to its proper type.  */
 452
 453 static void
 454 add_to_section_table (bfd *abfd, struct bfd_section *asect,
 455                       void *table_pp_char)
 456 {
 457   struct target_section **table_pp = (struct target_section **) table_pp_char;
 458   flagword aflag;
 459
 460   gdb_assert (abfd == asect->owner);
 461
 462   /* Check the section flags, but do not discard zero-length sections, since
 463      some symbols may still be attached to this section.  For instance, we
 464      encountered on sparc-solaris 2.10 a shared library with an empty .bss
 465      section to which a symbol named "_end" was attached.  The address
 466      of this symbol still needs to be relocated.  */
 467   aflag = bfd_get_section_flags (abfd, asect);
 468   if (!(aflag & SEC_ALLOC))
 469     return;
 470
 471   (*table_pp)->owner = NULL;
 472   (*table_pp)->the_bfd_section = asect;
 473   (*table_pp)->addr = bfd_section_vma (abfd, asect);
 474   (*table_pp)->endaddr = (*table_pp)->addr + bfd_section_size (abfd, asect);
 475   (*table_pp)++;
 476 }
 477
 478 /* See exec.h.  */
 479
 480 void
 481 clear_section_table (struct target_section_table *table)
 482 {
 483   xfree (table->sections);
 484   table->sections = table->sections_end = NULL;
 485 }
 486
 487 /* Resize section table TABLE by ADJUSTMENT.
 488    ADJUSTMENT may be negative, in which case the caller must have already
 489    removed the sections being deleted.
 490    Returns the old size.  */
 491
 492 static int
 493 resize_section_table (struct target_section_table *table, int adjustment)
 494 {
 495   int old_count;
 496   int new_count;
 497
 498   old_count = table->sections_end - table->sections;
 499
 500   new_count = adjustment + old_count;
 501
 502   if (new_count)
 503     {
 504       table->sections = XRESIZEVEC (struct target_section, table->sections,
 505                                     new_count);
 506       table->sections_end = table->sections + new_count;
 507     }
 508   else
 509     clear_section_table (table);
 510
 511   return old_count;
 512 }
 513
 514 /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
 515    Returns 0 if OK, 1 on error.  */
 516
 517 int
 518 build_section_table (struct bfd *some_bfd, struct target_section **start,
 519                      struct target_section **end)
 520 {
 521   unsigned count;
 522
 523   count = bfd_count_sections (some_bfd);
 524   if (*start)
 525     xfree (* start);
 526   *start = XNEWVEC (struct target_section, count);
 527   *end = *start;
 528   bfd_map_over_sections (some_bfd, add_to_section_table, (char *) end);
 529   if (*end > *start + count)
 530     internal_error (__FILE__, __LINE__,
 531                     _("failed internal consistency check"));
 532   /* We could realloc the table, but it probably loses for most files.  */
 533   return 0;
 534 }
 535
 536 /* Add the sections array defined by [SECTIONS..SECTIONS_END[ to the
 537    current set of target sections.  */
 538
 539 void
 540 add_target_sections (void *owner,
 541                      struct target_section *sections,
 542                      struct target_section *sections_end)
 543 {
 544   int count;
 545   struct target_section_table *table = current_target_sections;
 546
 547   count = sections_end - sections;
 548
 549   if (count > 0)
 550     {
 551       int space = resize_section_table (table, count);
 552       int i;
 553
 554       for (i = 0; i < count; ++i)
 555         {
 556           table->sections[space + i] = sections[i];
 557           table->sections[space + i].owner = owner;
 558         }
 559
 560       /* If these are the first file sections we can provide memory
 561          from, push the file_stratum target.  */
 562       if (!target_is_pushed (&exec_ops))
 563         push_target (&exec_ops);
 564     }
 565 }
 566
 567 /* Add the sections of OBJFILE to the current set of target sections.  */
 568
 569 void
 570 add_target_sections_of_objfile (struct objfile *objfile)
 571 {
 572   struct target_section_table *table = current_target_sections;
 573   struct obj_section *osect;
 574   int space;
 575   unsigned count = 0;
 576   struct target_section *ts;
 577
 578   if (objfile == NULL)
 579     return;
 580
 581   /* Compute the number of sections to add.  */
 582   ALL_OBJFILE_OSECTIONS (objfile, osect)
 583     {
 584       if (bfd_get_section_size (osect->the_bfd_section) == 0)
 585         continue;
 586       count++;
 587     }
 588
 589   if (count == 0)
 590     return;
 591
 592   space = resize_section_table (table, count);
 593
 594   ts = table->sections + space;
 595
 596   ALL_OBJFILE_OSECTIONS (objfile, osect)
 597     {
 598       if (bfd_get_section_size (osect->the_bfd_section) == 0)
 599         continue;
 600
 601       gdb_assert (ts < table->sections + space + count);
 602
 603       ts->addr = obj_section_addr (osect);
 604       ts->endaddr = obj_section_endaddr (osect);
 605       ts->the_bfd_section = osect->the_bfd_section;
 606       ts->owner = (void *) objfile;
 607
 608       ts++;
 609     }
 610 }
 611
 612 /* Remove all target sections owned by OWNER.
 613    OWNER must be the same value passed to add_target_sections.  */
 614
 615 void
 616 remove_target_sections (void *owner)
 617 {
 618   struct target_section *src, *dest;
 619   struct target_section_table *table = current_target_sections;
 620
 621   gdb_assert (owner != NULL);
 622
 623   dest = table->sections;
 624   for (src = table->sections; src < table->sections_end; src++)
 625     if (src->owner != owner)
 626       {
 627         /* Keep this section.  */
 628         if (dest < src)
 629           *dest = *src;
 630         dest++;
 631       }
 632
 633   /* If we've dropped any sections, resize the section table.  */
 634   if (dest < src)
 635     {
 636       int old_count;
 637
 638       old_count = resize_section_table (table, dest - src);
 639
 640       /* If we don't have any more sections to read memory from,
 641          remove the file_stratum target from the stack.  */
 642       if (old_count + (dest - src) == 0)
 643         {
 644           struct program_space *pspace;
 645
 646           ALL_PSPACES (pspace)
 647             if (pspace->target_sections.sections
 648                 != pspace->target_sections.sections_end)
 649               return;
 650
 651           unpush_target (&exec_ops);
 652         }
 653     }
 654 }
 655
 656 \f
 657
 658 enum target_xfer_status
 659 exec_read_partial_read_only (gdb_byte *readbuf, ULONGEST offset,
 660                              ULONGEST len, ULONGEST *xfered_len)
 661 {
 662   /* It's unduly pedantic to refuse to look at the executable for
 663      read-only pieces; so do the equivalent of readonly regions aka
 664      QTro packet.  */
 665   if (exec_bfd != NULL)
 666     {
 667       asection *s;
 668       bfd_size_type size;
 669       bfd_vma vma;
 670
 671       for (s = exec_bfd->sections; s; s = s->next)
 672         {
 673           if ((s->flags & SEC_LOAD) == 0
 674               || (s->flags & SEC_READONLY) == 0)
 675             continue;
 676
 677           vma = s->vma;
 678           size = bfd_get_section_size (s);
 679           if (vma <= offset && offset < (vma + size))
 680             {
 681               ULONGEST amt;
 682
 683               amt = (vma + size) - offset;
 684               if (amt > len)
 685                 amt = len;
 686
 687               amt = bfd_get_section_contents (exec_bfd, s,
 688                                               readbuf, offset - vma, amt);
 689
 690               if (amt == 0)
 691                 return TARGET_XFER_EOF;
 692               else
 693                 {
 694                   *xfered_len = amt;
 695                   return TARGET_XFER_OK;
 696                 }
 697             }
 698         }
 699     }
 700
 701   /* Indicate failure to find the requested memory block.  */
 702   return TARGET_XFER_E_IO;
 703 }
 704
 705 /* Appends all read-only memory ranges found in the target section
 706    table defined by SECTIONS and SECTIONS_END, starting at (and
 707    intersected with) MEMADDR for LEN bytes.  Returns the augmented
 708    VEC.  */
 709
 710 static VEC(mem_range_s) *
 711 section_table_available_memory (VEC(mem_range_s) *memory,
 712                                 CORE_ADDR memaddr, ULONGEST len,
 713                                 struct target_section *sections,
 714                                 struct target_section *sections_end)
 715 {
 716   struct target_section *p;
 717
 718   for (p = sections; p < sections_end; p++)
 719     {
 720       if ((bfd_get_section_flags (p->the_bfd_section->owner,
 721                                   p->the_bfd_section)
 722            & SEC_READONLY) == 0)
 723         continue;
 724
 725       /* Copy the meta-data, adjusted.  */
 726       if (mem_ranges_overlap (p->addr, p->endaddr - p->addr, memaddr, len))
 727         {
 728           ULONGEST lo1, hi1, lo2, hi2;
 729           struct mem_range *r;
 730
 731           lo1 = memaddr;
 732           hi1 = memaddr + len;
 733
 734           lo2 = p->addr;
 735           hi2 = p->endaddr;
 736
 737           r = VEC_safe_push (mem_range_s, memory, NULL);
 738
 739           r->start = std::max (lo1, lo2);
 740           r->length = std::min (hi1, hi2) - r->start;
 741         }
 742     }
 743
 744   return memory;
 745 }
 746
 747 enum target_xfer_status
 748 section_table_read_available_memory (gdb_byte *readbuf, ULONGEST offset,
 749                                      ULONGEST len, ULONGEST *xfered_len)
 750 {
 751   VEC(mem_range_s) *available_memory = NULL;
 752   struct target_section_table *table;
 753   struct cleanup *old_chain;
 754   mem_range_s *r;
 755   int i;
 756
 757   table = target_get_section_table (&exec_ops);
 758   available_memory = section_table_available_memory (available_memory,
 759                                                      offset, len,
 760                                                      table->sections,
 761                                                      table->sections_end);
 762
 763   old_chain = make_cleanup (VEC_cleanup(mem_range_s),
 764                             &available_memory);
 765
 766   normalize_mem_ranges (available_memory);
 767
 768   for (i = 0;
 769        VEC_iterate (mem_range_s, available_memory, i, r);
 770        i++)
 771     {
 772       if (mem_ranges_overlap (r->start, r->length, offset, len))
 773         {
 774           CORE_ADDR end;
 775           enum target_xfer_status status;
 776
 777           /* Get the intersection window.  */
 778           end = std::min<CORE_ADDR> (offset + len, r->start + r->length);
 779
 780           gdb_assert (end - offset <= len);
 781
 782           if (offset >= r->start)
 783             status = exec_read_partial_read_only (readbuf, offset,
 784                                                   end - offset,
 785                                                   xfered_len);
 786           else
 787             {
 788               *xfered_len = r->start - offset;
 789               status = TARGET_XFER_UNAVAILABLE;
 790             }
 791           do_cleanups (old_chain);
 792           return status;
 793         }
 794     }
 795   do_cleanups (old_chain);
 796
 797   *xfered_len = len;
 798   return TARGET_XFER_UNAVAILABLE;
 799 }
 800
 801 enum target_xfer_status
 802 section_table_xfer_memory_partial (gdb_byte *readbuf, const gdb_byte *writebuf,
 803                                    ULONGEST offset, ULONGEST len,
 804                                    ULONGEST *xfered_len,
 805                                    struct target_section *sections,
 806                                    struct target_section *sections_end,
 807                                    const char *section_name)
 808 {
 809   int res;
 810   struct target_section *p;
 811   ULONGEST memaddr = offset;
 812   ULONGEST memend = memaddr + len;
 813
 814   if (len == 0)
 815     internal_error (__FILE__, __LINE__,
 816                     _("failed internal consistency check"));
 817
 818   for (p = sections; p < sections_end; p++)
 819     {
 820       struct bfd_section *asect = p->the_bfd_section;
 821       bfd *abfd = asect->owner;
 822
 823       if (section_name && strcmp (section_name, asect->name) != 0)
 824         continue;               /* not the section we need.  */
 825       if (memaddr >= p->addr)
 826         {
 827           if (memend <= p->endaddr)
 828             {
 829               /* Entire transfer is within this section.  */
 830               if (writebuf)
 831                 res = bfd_set_section_contents (abfd, asect,
 832                                                 writebuf, memaddr - p->addr,
 833                                                 len);
 834               else
 835                 res = bfd_get_section_contents (abfd, asect,
 836                                                 readbuf, memaddr - p->addr,
 837                                                 len);
 838
 839               if (res != 0)
 840                 {
 841                   *xfered_len = len;
 842                   return TARGET_XFER_OK;
 843                 }
 844               else
 845                 return TARGET_XFER_EOF;
 846             }
 847           else if (memaddr >= p->endaddr)
 848             {
 849               /* This section ends before the transfer starts.  */
 850               continue;
 851             }
 852           else
 853             {
 854               /* This section overlaps the transfer.  Just do half.  */
 855               len = p->endaddr - memaddr;
 856               if (writebuf)
 857                 res = bfd_set_section_contents (abfd, asect,
 858                                                 writebuf, memaddr - p->addr,
 859                                                 len);
 860               else
 861                 res = bfd_get_section_contents (abfd, asect,
 862                                                 readbuf, memaddr - p->addr,
 863                                                 len);
 864               if (res != 0)
 865                 {
 866                   *xfered_len = len;
 867                   return TARGET_XFER_OK;
 868                 }
 869               else
 870                 return TARGET_XFER_EOF;
 871             }
 872         }
 873     }
 874
 875   return TARGET_XFER_EOF;               /* We can't help.  */
 876 }
 877
 878 static struct target_section_table *
 879 exec_get_section_table (struct target_ops *ops)
 880 {
 881   return current_target_sections;
 882 }
 883
 884 static enum target_xfer_status
 885 exec_xfer_partial (struct target_ops *ops, enum target_object object,
 886                    const char *annex, gdb_byte *readbuf,
 887                    const gdb_byte *writebuf,
 888                    ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
 889 {
 890   struct target_section_table *table = target_get_section_table (ops);
 891
 892   if (object == TARGET_OBJECT_MEMORY)
 893     return section_table_xfer_memory_partial (readbuf, writebuf,
 894                                               offset, len, xfered_len,
 895                                               table->sections,
 896                                               table->sections_end,
 897                                               NULL);
 898   else
 899     return TARGET_XFER_E_IO;
 900 }
 901 \f
 902
 903 void
 904 print_section_info (struct target_section_table *t, bfd *abfd)
 905 {
 906   struct gdbarch *gdbarch = gdbarch_from_bfd (abfd);
 907   struct target_section *p;
 908   /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64.  */
 909   int wid = gdbarch_addr_bit (gdbarch) <= 32 ? 8 : 16;
 910
 911   printf_filtered ("\t`%s', ", bfd_get_filename (abfd));
 912   wrap_here ("        ");
 913   printf_filtered (_("file type %s.\n"), bfd_get_target (abfd));
 914   if (abfd == exec_bfd)
 915     {
 916       /* gcc-3.4 does not like the initialization in
 917          <p == t->sections_end>.  */
 918       bfd_vma displacement = 0;
 919       bfd_vma entry_point;
 920
 921       for (p = t->sections; p < t->sections_end; p++)
 922         {
 923           struct bfd_section *psect = p->the_bfd_section;
 924           bfd *pbfd = psect->owner;
 925
 926           if ((bfd_get_section_flags (pbfd, psect) & (SEC_ALLOC | SEC_LOAD))
 927               != (SEC_ALLOC | SEC_LOAD))
 928             continue;
 929
 930           if (bfd_get_section_vma (pbfd, psect) <= abfd->start_address
 931               && abfd->start_address < (bfd_get_section_vma (pbfd, psect)
 932                                         + bfd_get_section_size (psect)))
 933             {
 934               displacement = p->addr - bfd_get_section_vma (pbfd, psect);
 935               break;
 936             }
 937         }
 938       if (p == t->sections_end)
 939         warning (_("Cannot find section for the entry point of %s."),
 940                  bfd_get_filename (abfd));
 941
 942       entry_point = gdbarch_addr_bits_remove (gdbarch,
 943                                               bfd_get_start_address (abfd)
 944                                                 + displacement);
 945       printf_filtered (_("\tEntry point: %s\n"),
 946                        paddress (gdbarch, entry_point));
 947     }
 948   for (p = t->sections; p < t->sections_end; p++)
 949     {
 950       struct bfd_section *psect = p->the_bfd_section;
 951       bfd *pbfd = psect->owner;
 952
 953       printf_filtered ("\t%s", hex_string_custom (p->addr, wid));
 954       printf_filtered (" - %s", hex_string_custom (p->endaddr, wid));
 955
 956       /* FIXME: A format of "08l" is not wide enough for file offsets
 957          larger than 4GB.  OTOH, making it "016l" isn't desirable either
 958          since most output will then be much wider than necessary.  It
 959          may make sense to test the size of the file and choose the
 960          format string accordingly.  */
 961       /* FIXME: i18n: Need to rewrite this sentence.  */
 962       if (info_verbose)
 963         printf_filtered (" @ %s",
 964                          hex_string_custom (psect->filepos, 8));
 965       printf_filtered (" is %s", bfd_section_name (pbfd, psect));
 966       if (pbfd != abfd)
 967         printf_filtered (" in %s", bfd_get_filename (pbfd));
 968       printf_filtered ("\n");
 969     }
 970 }
 971
 972 static void
 973 exec_files_info (struct target_ops *t)
 974 {
 975   if (exec_bfd)
 976     print_section_info (current_target_sections, exec_bfd);
 977   else
 978     puts_filtered (_("\t<no file loaded>\n"));
 979 }
 980
 981 static void
 982 set_section_command (char *args, int from_tty)
 983 {
 984   struct target_section *p;
 985   char *secname;
 986   unsigned seclen;
 987   unsigned long secaddr;
 988   char secprint[100];
 989   long offset;
 990   struct target_section_table *table;
 991
 992   if (args == 0)
 993     error (_("Must specify section name and its virtual address"));
 994
 995   /* Parse out section name.  */
 996   for (secname = args; !isspace (*args); args++);
 997   seclen = args - secname;
 998
 999   /* Parse out new virtual address.  */
1000   secaddr = parse_and_eval_address (args);
1001
1002   table = current_target_sections;
1003   for (p = table->sections; p < table->sections_end; p++)
1004     {
1005       if (!strncmp (secname, bfd_section_name (p->bfd,
1006                                                p->the_bfd_section), seclen)
1007           && bfd_section_name (p->bfd, p->the_bfd_section)[seclen] == '\0')
1008         {
1009           offset = secaddr - p->addr;
1010           p->addr += offset;
1011           p->endaddr += offset;
1012           if (from_tty)
1013             exec_files_info (&exec_ops);
1014           return;
1015         }
1016     }
1017   if (seclen >= sizeof (secprint))
1018     seclen = sizeof (secprint) - 1;
1019   strncpy (secprint, secname, seclen);
1020   secprint[seclen] = '\0';
1021   error (_("Section %s not found"), secprint);
1022 }
1023
1024 /* If we can find a section in FILENAME with BFD index INDEX, adjust
1025    it to ADDRESS.  */
1026
1027 void
1028 exec_set_section_address (const char *filename, int index, CORE_ADDR address)
1029 {
1030   struct target_section *p;
1031   struct target_section_table *table;
1032
1033   table = current_target_sections;
1034   for (p = table->sections; p < table->sections_end; p++)
1035     {
1036       if (filename_cmp (filename, p->the_bfd_section->owner->filename) == 0
1037           && index == p->the_bfd_section->index)
1038         {
1039           p->endaddr += address - p->addr;
1040           p->addr = address;
1041         }
1042     }
1043 }
1044
1045 /* If mourn is being called in all the right places, this could be say
1046    `gdb internal error' (since generic_mourn calls
1047    breakpoint_init_inferior).  */
1048
1049 static int
1050 ignore (struct target_ops *ops, struct gdbarch *gdbarch,
1051         struct bp_target_info *bp_tgt)
1052 {
1053   return 0;
1054 }
1055
1056 /* Implement the to_remove_breakpoint method.  */
1057
1058 static int
1059 exec_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
1060                         struct bp_target_info *bp_tgt,
1061                         enum remove_bp_reason reason)
1062 {
1063   return 0;
1064 }
1065
1066 static int
1067 exec_has_memory (struct target_ops *ops)
1068 {
1069   /* We can provide memory if we have any file/target sections to read
1070      from.  */
1071   return (current_target_sections->sections
1072           != current_target_sections->sections_end);
1073 }
1074
1075 static char *
1076 exec_make_note_section (struct target_ops *self, bfd *obfd, int *note_size)
1077 {
1078   error (_("Can't create a corefile"));
1079 }
1080
1081 /* Fill in the exec file target vector.  Very few entries need to be
1082    defined.  */
1083
1084 static void
1085 init_exec_ops (void)
1086 {
1087   exec_ops.to_shortname = "exec";
1088   exec_ops.to_longname = "Local exec file";
1089   exec_ops.to_doc = "Use an executable file as a target.\n\
1090 Specify the filename of the executable file.";
1091   exec_ops.to_open = exec_open;
1092   exec_ops.to_close = exec_close_1;
1093   exec_ops.to_xfer_partial = exec_xfer_partial;
1094   exec_ops.to_get_section_table = exec_get_section_table;
1095   exec_ops.to_files_info = exec_files_info;
1096   exec_ops.to_insert_breakpoint = ignore;
1097   exec_ops.to_remove_breakpoint = exec_remove_breakpoint;
1098   exec_ops.to_stratum = file_stratum;
1099   exec_ops.to_has_memory = exec_has_memory;
1100   exec_ops.to_make_corefile_notes = exec_make_note_section;
1101   exec_ops.to_find_memory_regions = objfile_find_memory_regions;
1102   exec_ops.to_magic = OPS_MAGIC;
1103 }
1104
1105 void
1106 _initialize_exec (void)
1107 {
1108   struct cmd_list_element *c;
1109
1110   init_exec_ops ();
1111
1112   if (!dbx_commands)
1113     {
1114       c = add_cmd ("file", class_files, file_command, _("\
1115 Use FILE as program to be debugged.\n\
1116 It is read for its symbols, for getting the contents of pure memory,\n\
1117 and it is the program executed when you use the `run' command.\n\
1118 If FILE cannot be found as specified, your execution directory path\n\
1119 ($PATH) is searched for a command of that name.\n\
1120 No arg means to have no executable file and no symbols."), &cmdlist);
1121       set_cmd_completer (c, filename_completer);
1122     }
1123
1124   c = add_cmd ("exec-file", class_files, exec_file_command, _("\
1125 Use FILE as program for getting contents of pure memory.\n\
1126 If FILE cannot be found as specified, your execution directory path\n\
1127 is searched for a command of that name.\n\
1128 No arg means have no executable file."), &cmdlist);
1129   set_cmd_completer (c, filename_completer);
1130
1131   add_com ("section", class_files, set_section_command, _("\
1132 Change the base address of section SECTION of the exec file to ADDR.\n\
1133 This can be used if the exec file does not contain section addresses,\n\
1134 (such as in the a.out format), or when the addresses specified in the\n\
1135 file itself are wrong.  Each section must be changed separately.  The\n\
1136 ``info files'' command lists all the sections and their addresses."));
1137
1138   add_setshow_boolean_cmd ("write", class_support, &write_files, _("\
1139 Set writing into executable and core files."), _("\
1140 Show writing into executable and core files."), NULL,
1141                            NULL,
1142                            show_write_files,
1143                            &setlist, &showlist);
1144
1145   add_target_with_completer (&exec_ops, filename_completer);
1146 }