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