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