gdb/exec.c

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