gdb/exec.c

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