gdb/exec.c

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