gdb/exec.c

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