gdb/exec.c

   1 /* Work with executable files, for GDB.
   2    Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
   3    1998, 1999, 2000, 2001, 2002
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 #include "defs.h"
  24 #include "frame.h"
  25 #include "inferior.h"
  26 #include "target.h"
  27 #include "gdbcmd.h"
  28 #include "language.h"
  29 #include "symfile.h"
  30 #include "objfiles.h"
  31 #include "completer.h"
  32 #include "value.h"
  33
  34 #ifdef USG
  35 #include <sys/types.h>
  36 #endif
  37
  38 #include <fcntl.h>
  39 #include "gdb_string.h"
  40
  41 #include "gdbcore.h"
  42
  43 #include <ctype.h>
  44 #include "gdb_stat.h"
  45 #ifndef O_BINARY
  46 #define O_BINARY 0
  47 #endif
  48
  49 #include "xcoffsolib.h"
  50
  51 struct vmap *map_vmap (bfd *, bfd *);
  52
  53 void (*file_changed_hook) (char *);
  54
  55 /* Prototypes for local functions */
  56
  57 static void add_to_section_table (bfd *, sec_ptr, PTR);
  58
  59 static void exec_close (int);
  60
  61 static void file_command (char *, int);
  62
  63 static void set_section_command (char *, int);
  64
  65 static void exec_files_info (struct target_ops *);
  66
  67 static void bfdsec_to_vmap (bfd *, sec_ptr, PTR);
  68
  69 static int ignore (CORE_ADDR, char *);
  70
  71 static void init_exec_ops (void);
  72
  73 void _initialize_exec (void);
  74
  75 /* The target vector for executable files.  */
  76
  77 struct target_ops exec_ops;
  78
  79 /* The Binary File Descriptor handle for the executable file.  */
  80
  81 bfd *exec_bfd = NULL;
  82
  83 /* Whether to open exec and core files read-only or read-write.  */
  84
  85 int write_files = 0;
  86
  87 /* Text start and end addresses (KLUDGE) if needed */
  88
  89 #ifndef NEED_TEXT_START_END
  90 #define NEED_TEXT_START_END (0)
  91 #endif
  92 CORE_ADDR text_start = 0;
  93 CORE_ADDR text_end = 0;
  94
  95 struct vmap *vmap;
  96
  97 void
  98 exec_open (char *args, int from_tty)
  99 {
 100   target_preopen (from_tty);
 101   exec_file_attach (args, from_tty);
 102 }
 103
 104 /* ARGSUSED */
 105 static void
 106 exec_close (int quitting)
 107 {
 108   int need_symtab_cleanup = 0;
 109   struct vmap *vp, *nxt;
 110
 111   for (nxt = vmap; nxt != NULL;)
 112     {
 113       vp = nxt;
 114       nxt = vp->nxt;
 115
 116       /* if there is an objfile associated with this bfd,
 117          free_objfile() will do proper cleanup of objfile *and* bfd. */
 118
 119       if (vp->objfile)
 120         {
 121           free_objfile (vp->objfile);
 122           need_symtab_cleanup = 1;
 123         }
 124       else if (vp->bfd != exec_bfd)
 125         /* FIXME-leak: We should be freeing vp->name too, I think.  */
 126         if (!bfd_close (vp->bfd))
 127           warning ("cannot close \"%s\": %s",
 128                    vp->name, bfd_errmsg (bfd_get_error ()));
 129
 130       /* FIXME: This routine is #if 0'd in symfile.c.  What should we
 131          be doing here?  Should we just free everything in
 132          vp->objfile->symtabs?  Should free_objfile do that?
 133          FIXME-as-well: free_objfile already free'd vp->name, so it isn't
 134          valid here.  */
 135       free_named_symtabs (vp->name);
 136       xfree (vp);
 137     }
 138
 139   vmap = NULL;
 140
 141   if (exec_bfd)
 142     {
 143       char *name = bfd_get_filename (exec_bfd);
 144
 145       if (!bfd_close (exec_bfd))
 146         warning ("cannot close \"%s\": %s",
 147                  name, bfd_errmsg (bfd_get_error ()));
 148       xfree (name);
 149       exec_bfd = NULL;
 150     }
 151
 152   if (exec_ops.to_sections)
 153     {
 154       xfree (exec_ops.to_sections);
 155       exec_ops.to_sections = NULL;
 156       exec_ops.to_sections_end = NULL;
 157     }
 158 }
 159
 160 void
 161 exec_file_clear (int from_tty)
 162 {
 163   /* Remove exec file.  */
 164   unpush_target (&exec_ops);
 165
 166   if (from_tty)
 167     printf_unfiltered ("No executable file now.\n");
 168 }
 169
 170 /*  Process the first arg in ARGS as the new exec file.
 171
 172    This function is intended to be behave essentially the same
 173    as exec_file_command, except that the latter will detect when
 174    a target is being debugged, and will ask the user whether it
 175    should be shut down first.  (If the answer is "no", then the
 176    new file is ignored.)
 177
 178    This file is used by exec_file_command, to do the work of opening
 179    and processing the exec file after any prompting has happened.
 180
 181    And, it is used by child_attach, when the attach command was
 182    given a pid but not a exec pathname, and the attach command could
 183    figure out the pathname from the pid.  (In this case, we shouldn't
 184    ask the user whether the current target should be shut down --
 185    we're supplying the exec pathname late for good reason.)
 186
 187    ARGS is assumed to be the filename. */
 188
 189 void
 190 exec_file_attach (char *filename, int from_tty)
 191 {
 192   /* Remove any previous exec file.  */
 193   unpush_target (&exec_ops);
 194
 195   /* Now open and digest the file the user requested, if any.  */
 196
 197   if (!filename)
 198     {
 199       if (from_tty)
 200         printf_unfiltered ("No executable file now.\n");
 201     }
 202   else
 203     {
 204       char *scratch_pathname;
 205       int scratch_chan;
 206
 207       scratch_chan = openp (getenv ("PATH"), 1, filename,
 208                    write_files ? O_RDWR | O_BINARY : O_RDONLY | O_BINARY, 0,
 209                             &scratch_pathname);
 210 #if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
 211       if (scratch_chan < 0)
 212         {
 213           char *exename = alloca (strlen (filename) + 5);
 214           strcat (strcpy (exename, filename), ".exe");
 215           scratch_chan = openp (getenv ("PATH"), 1, exename, write_files ?
 216              O_RDWR | O_BINARY : O_RDONLY | O_BINARY, 0, &scratch_pathname);
 217         }
 218 #endif
 219       if (scratch_chan < 0)
 220         perror_with_name (filename);
 221       exec_bfd = bfd_fdopenr (scratch_pathname, gnutarget, scratch_chan);
 222
 223       if (!exec_bfd)
 224         error ("\"%s\": could not open as an executable file: %s",
 225                scratch_pathname, bfd_errmsg (bfd_get_error ()));
 226
 227       /* At this point, scratch_pathname and exec_bfd->name both point to the
 228          same malloc'd string.  However exec_close() will attempt to free it
 229          via the exec_bfd->name pointer, so we need to make another copy and
 230          leave exec_bfd as the new owner of the original copy. */
 231       scratch_pathname = xstrdup (scratch_pathname);
 232       make_cleanup (xfree, scratch_pathname);
 233
 234       if (!bfd_check_format (exec_bfd, bfd_object))
 235         {
 236           /* Make sure to close exec_bfd, or else "run" might try to use
 237              it.  */
 238           exec_close (0);
 239           error ("\"%s\": not in executable format: %s",
 240                  scratch_pathname, bfd_errmsg (bfd_get_error ()));
 241         }
 242
 243       /* FIXME - This should only be run for RS6000, but the ifdef is a poor
 244          way to accomplish.  */
 245 #ifdef IBM6000_TARGET
 246       /* Setup initial vmap. */
 247
 248       map_vmap (exec_bfd, 0);
 249       if (vmap == NULL)
 250         {
 251           /* Make sure to close exec_bfd, or else "run" might try to use
 252              it.  */
 253           exec_close (0);
 254           error ("\"%s\": can't find the file sections: %s",
 255                  scratch_pathname, bfd_errmsg (bfd_get_error ()));
 256         }
 257 #endif /* IBM6000_TARGET */
 258
 259       if (build_section_table (exec_bfd, &exec_ops.to_sections,
 260                                &exec_ops.to_sections_end))
 261         {
 262           /* Make sure to close exec_bfd, or else "run" might try to use
 263              it.  */
 264           exec_close (0);
 265           error ("\"%s\": can't find the file sections: %s",
 266                  scratch_pathname, bfd_errmsg (bfd_get_error ()));
 267         }
 268
 269       /* text_end is sometimes used for where to put call dummies.  A
 270          few ports use these for other purposes too.  */
 271       if (NEED_TEXT_START_END)
 272         {
 273           struct section_table *p;
 274
 275           /* Set text_start to the lowest address of the start of any
 276              readonly code section and set text_end to the highest
 277              address of the end of any readonly code section.  */
 278           /* FIXME: The comment above does not match the code.  The
 279              code checks for sections with are either code *or*
 280              readonly.  */
 281           text_start = ~(CORE_ADDR) 0;
 282           text_end = (CORE_ADDR) 0;
 283           for (p = exec_ops.to_sections; p < exec_ops.to_sections_end; p++)
 284             if (bfd_get_section_flags (p->bfd, p->the_bfd_section)
 285                 & (SEC_CODE | SEC_READONLY))
 286               {
 287                 if (text_start > p->addr)
 288                   text_start = p->addr;
 289                 if (text_end < p->endaddr)
 290                   text_end = p->endaddr;
 291               }
 292         }
 293
 294       validate_files ();
 295
 296       set_gdbarch_from_file (exec_bfd);
 297
 298       push_target (&exec_ops);
 299
 300       /* Tell display code (if any) about the changed file name.  */
 301       if (exec_file_display_hook)
 302         (*exec_file_display_hook) (filename);
 303     }
 304 }
 305
 306 /*  Process the first arg in ARGS as the new exec file.
 307
 308    Note that we have to explicitly ignore additional args, since we can
 309    be called from file_command(), which also calls symbol_file_command()
 310    which can take multiple args.
 311
 312    If ARGS is NULL, we just want to close the exec file. */
 313
 314 static void
 315 exec_file_command (char *args, int from_tty)
 316 {
 317   char **argv;
 318   char *filename;
 319
 320   target_preopen (from_tty);
 321
 322   if (args)
 323     {
 324       /* Scan through the args and pick up the first non option arg
 325          as the filename.  */
 326
 327       argv = buildargv (args);
 328       if (argv == NULL)
 329         nomem (0);
 330
 331       make_cleanup_freeargv (argv);
 332
 333       for (; (*argv != NULL) && (**argv == '-'); argv++)
 334         {;
 335         }
 336       if (*argv == NULL)
 337         error ("No executable file name was specified");
 338
 339       filename = tilde_expand (*argv);
 340       make_cleanup (xfree, filename);
 341       exec_file_attach (filename, from_tty);
 342     }
 343   else
 344     exec_file_attach (NULL, from_tty);
 345 }
 346
 347 /* Set both the exec file and the symbol file, in one command.
 348    What a novelty.  Why did GDB go through four major releases before this
 349    command was added?  */
 350
 351 static void
 352 file_command (char *arg, int from_tty)
 353 {
 354   /* FIXME, if we lose on reading the symbol file, we should revert
 355      the exec file, but that's rough.  */
 356   exec_file_command (arg, from_tty);
 357   symbol_file_command (arg, from_tty);
 358   if (file_changed_hook)
 359     file_changed_hook (arg);
 360 }
 361 \f
 362
 363 /* Locate all mappable sections of a BFD file.
 364    table_pp_char is a char * to get it through bfd_map_over_sections;
 365    we cast it back to its proper type.  */
 366
 367 static void
 368 add_to_section_table (bfd *abfd, sec_ptr asect, PTR table_pp_char)
 369 {
 370   struct section_table **table_pp = (struct section_table **) table_pp_char;
 371   flagword aflag;
 372
 373   aflag = bfd_get_section_flags (abfd, asect);
 374   if (!(aflag & SEC_ALLOC))
 375     return;
 376   if (0 == bfd_section_size (abfd, asect))
 377     return;
 378   (*table_pp)->bfd = abfd;
 379   (*table_pp)->the_bfd_section = asect;
 380   (*table_pp)->addr = bfd_section_vma (abfd, asect);
 381   (*table_pp)->endaddr = (*table_pp)->addr + bfd_section_size (abfd, asect);
 382   (*table_pp)++;
 383 }
 384
 385 /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
 386    Returns 0 if OK, 1 on error.  */
 387
 388 int
 389 build_section_table (bfd *some_bfd, struct section_table **start,
 390                      struct section_table **end)
 391 {
 392   unsigned count;
 393
 394   count = bfd_count_sections (some_bfd);
 395   if (*start)
 396     xfree (* start);
 397   *start = (struct section_table *) xmalloc (count * sizeof (**start));
 398   *end = *start;
 399   bfd_map_over_sections (some_bfd, add_to_section_table, (char *) end);
 400   if (*end > *start + count)
 401     internal_error (__FILE__, __LINE__, "failed internal consistency check");
 402   /* We could realloc the table, but it probably loses for most files.  */
 403   return 0;
 404 }
 405 \f
 406 static void
 407 bfdsec_to_vmap (bfd *abfd, sec_ptr sect, PTR arg3)
 408 {
 409   struct vmap_and_bfd *vmap_bfd = (struct vmap_and_bfd *) arg3;
 410   struct vmap *vp;
 411
 412   vp = vmap_bfd->pvmap;
 413
 414   if ((bfd_get_section_flags (abfd, sect) & SEC_LOAD) == 0)
 415     return;
 416
 417   if (STREQ (bfd_section_name (abfd, sect), ".text"))
 418     {
 419       vp->tstart = bfd_section_vma (abfd, sect);
 420       vp->tend = vp->tstart + bfd_section_size (abfd, sect);
 421       vp->tvma = bfd_section_vma (abfd, sect);
 422       vp->toffs = sect->filepos;
 423     }
 424   else if (STREQ (bfd_section_name (abfd, sect), ".data"))
 425     {
 426       vp->dstart = bfd_section_vma (abfd, sect);
 427       vp->dend = vp->dstart + bfd_section_size (abfd, sect);
 428       vp->dvma = bfd_section_vma (abfd, sect);
 429     }
 430   /* Silently ignore other types of sections. (FIXME?)  */
 431 }
 432
 433 /* Make a vmap for ABFD which might be a member of the archive ARCH.
 434    Return the new vmap.  */
 435
 436 struct vmap *
 437 map_vmap (bfd *abfd, bfd *arch)
 438 {
 439   struct vmap_and_bfd vmap_bfd;
 440   struct vmap *vp, **vpp;
 441
 442   vp = (struct vmap *) xmalloc (sizeof (*vp));
 443   memset ((char *) vp, '\0', sizeof (*vp));
 444   vp->nxt = 0;
 445   vp->bfd = abfd;
 446   vp->name = bfd_get_filename (arch ? arch : abfd);
 447   vp->member = arch ? bfd_get_filename (abfd) : "";
 448
 449   vmap_bfd.pbfd = arch;
 450   vmap_bfd.pvmap = vp;
 451   bfd_map_over_sections (abfd, bfdsec_to_vmap, &vmap_bfd);
 452
 453   /* Find the end of the list and append. */
 454   for (vpp = &vmap; *vpp; vpp = &(*vpp)->nxt)
 455     ;
 456   *vpp = vp;
 457
 458   return vp;
 459 }
 460 \f
 461 /* Read or write the exec file.
 462
 463    Args are address within a BFD file, address within gdb address-space,
 464    length, and a flag indicating whether to read or write.
 465
 466    Result is a length:
 467
 468    0:    We cannot handle this address and length.
 469    > 0:  We have handled N bytes starting at this address.
 470    (If N == length, we did it all.)  We might be able
 471    to handle more bytes beyond this length, but no
 472    promises.
 473    < 0:  We cannot handle this address, but if somebody
 474    else handles (-N) bytes, we can start from there.
 475
 476    The same routine is used to handle both core and exec files;
 477    we just tail-call it with more arguments to select between them.  */
 478
 479 int
 480 xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
 481              struct mem_attrib *attrib,
 482              struct target_ops *target)
 483 {
 484   boolean res;
 485   struct section_table *p;
 486   CORE_ADDR nextsectaddr, memend;
 487   boolean (*xfer_fn) (bfd *, sec_ptr, PTR, file_ptr, bfd_size_type);
 488   asection *section = NULL;
 489
 490   if (len <= 0)
 491     internal_error (__FILE__, __LINE__, "failed internal consistency check");
 492
 493   if (overlay_debugging)
 494     {
 495       section = find_pc_overlay (memaddr);
 496       if (pc_in_unmapped_range (memaddr, section))
 497         memaddr = overlay_mapped_address (memaddr, section);
 498     }
 499
 500   memend = memaddr + len;
 501   xfer_fn = write ? bfd_set_section_contents : bfd_get_section_contents;
 502   nextsectaddr = memend;
 503
 504   for (p = target->to_sections; p < target->to_sections_end; p++)
 505     {
 506       if (overlay_debugging && section && p->the_bfd_section &&
 507           strcmp (section->name, p->the_bfd_section->name) != 0)
 508         continue;               /* not the section we need */
 509       if (memaddr >= p->addr)
 510         if (memend <= p->endaddr)
 511           {
 512             /* Entire transfer is within this section.  */
 513             res = xfer_fn (p->bfd, p->the_bfd_section, myaddr,
 514                            memaddr - p->addr, len);
 515             return (res != 0) ? len : 0;
 516           }
 517         else if (memaddr >= p->endaddr)
 518           {
 519             /* This section ends before the transfer starts.  */
 520             continue;
 521           }
 522         else
 523           {
 524             /* This section overlaps the transfer.  Just do half.  */
 525             len = p->endaddr - memaddr;
 526             res = xfer_fn (p->bfd, p->the_bfd_section, myaddr,
 527                            memaddr - p->addr, len);
 528             return (res != 0) ? len : 0;
 529           }
 530       else
 531         nextsectaddr = min (nextsectaddr, p->addr);
 532     }
 533
 534   if (nextsectaddr >= memend)
 535     return 0;                   /* We can't help */
 536   else
 537     return -(nextsectaddr - memaddr);   /* Next boundary where we can help */
 538 }
 539 \f
 540
 541 void
 542 print_section_info (struct target_ops *t, bfd *abfd)
 543 {
 544   struct section_table *p;
 545
 546   printf_filtered ("\t`%s', ", bfd_get_filename (abfd));
 547   wrap_here ("        ");
 548   printf_filtered ("file type %s.\n", bfd_get_target (abfd));
 549   if (abfd == exec_bfd)
 550     {
 551       printf_filtered ("\tEntry point: ");
 552       print_address_numeric (bfd_get_start_address (abfd), 1, gdb_stdout);
 553       printf_filtered ("\n");
 554     }
 555   for (p = t->to_sections; p < t->to_sections_end; p++)
 556     {
 557       /* FIXME-32x64 need a print_address_numeric with field width */
 558       printf_filtered ("\t%s", local_hex_string_custom ((unsigned long) p->addr, "08l"));
 559       printf_filtered (" - %s", local_hex_string_custom ((unsigned long) p->endaddr, "08l"));
 560       if (info_verbose)
 561         printf_filtered (" @ %s",
 562                          local_hex_string_custom ((unsigned long) p->the_bfd_section->filepos, "08l"));
 563       printf_filtered (" is %s", bfd_section_name (p->bfd, p->the_bfd_section));
 564       if (p->bfd != abfd)
 565         {
 566           printf_filtered (" in %s", bfd_get_filename (p->bfd));
 567         }
 568       printf_filtered ("\n");
 569     }
 570 }
 571
 572 static void
 573 exec_files_info (struct target_ops *t)
 574 {
 575   print_section_info (t, exec_bfd);
 576
 577   if (vmap)
 578     {
 579       struct vmap *vp;
 580
 581       printf_unfiltered ("\tMapping info for file `%s'.\n", vmap->name);
 582       printf_unfiltered ("\t  %*s   %*s   %*s   %*s %8.8s %s\n",
 583                          strlen_paddr (), "tstart",
 584                          strlen_paddr (), "tend",
 585                          strlen_paddr (), "dstart",
 586                          strlen_paddr (), "dend",
 587                          "section",
 588                          "file(member)");
 589
 590       for (vp = vmap; vp; vp = vp->nxt)
 591         printf_unfiltered ("\t0x%s 0x%s 0x%s 0x%s %s%s%s%s\n",
 592                            paddr (vp->tstart),
 593                            paddr (vp->tend),
 594                            paddr (vp->dstart),
 595                            paddr (vp->dend),
 596                            vp->name,
 597                            *vp->member ? "(" : "", vp->member,
 598                            *vp->member ? ")" : "");
 599     }
 600 }
 601
 602 /* msnyder 5/21/99:
 603    exec_set_section_offsets sets the offsets of all the sections
 604    in the exec objfile.  */
 605
 606 void
 607 exec_set_section_offsets (bfd_signed_vma text_off, bfd_signed_vma data_off,
 608                           bfd_signed_vma bss_off)
 609 {
 610   struct section_table *sect;
 611
 612   for (sect = exec_ops.to_sections;
 613        sect < exec_ops.to_sections_end;
 614        sect++)
 615     {
 616       flagword flags;
 617
 618       flags = bfd_get_section_flags (exec_bfd, sect->the_bfd_section);
 619
 620       if (flags & SEC_CODE)
 621         {
 622           sect->addr += text_off;
 623           sect->endaddr += text_off;
 624         }
 625       else if (flags & (SEC_DATA | SEC_LOAD))
 626         {
 627           sect->addr += data_off;
 628           sect->endaddr += data_off;
 629         }
 630       else if (flags & SEC_ALLOC)
 631         {
 632           sect->addr += bss_off;
 633           sect->endaddr += bss_off;
 634         }
 635     }
 636 }
 637
 638 static void
 639 set_section_command (char *args, int from_tty)
 640 {
 641   struct section_table *p;
 642   char *secname;
 643   unsigned seclen;
 644   unsigned long secaddr;
 645   char secprint[100];
 646   long offset;
 647
 648   if (args == 0)
 649     error ("Must specify section name and its virtual address");
 650
 651   /* Parse out section name */
 652   for (secname = args; !isspace (*args); args++);
 653   seclen = args - secname;
 654
 655   /* Parse out new virtual address */
 656   secaddr = parse_and_eval_address (args);
 657
 658   for (p = exec_ops.to_sections; p < exec_ops.to_sections_end; p++)
 659     {
 660       if (!strncmp (secname, bfd_section_name (exec_bfd, p->the_bfd_section), seclen)
 661           && bfd_section_name (exec_bfd, p->the_bfd_section)[seclen] == '\0')
 662         {
 663           offset = secaddr - p->addr;
 664           p->addr += offset;
 665           p->endaddr += offset;
 666           if (from_tty)
 667             exec_files_info (&exec_ops);
 668           return;
 669         }
 670     }
 671   if (seclen >= sizeof (secprint))
 672     seclen = sizeof (secprint) - 1;
 673   strncpy (secprint, secname, seclen);
 674   secprint[seclen] = '\0';
 675   error ("Section %s not found", secprint);
 676 }
 677
 678 /* If mourn is being called in all the right places, this could be say
 679    `gdb internal error' (since generic_mourn calls
 680    breakpoint_init_inferior).  */
 681
 682 static int
 683 ignore (CORE_ADDR addr, char *contents)
 684 {
 685   return 0;
 686 }
 687
 688 /* Find mapped memory. */
 689
 690 extern void
 691 exec_set_find_memory_regions (int (*func) (int (*) (CORE_ADDR,
 692                                                     unsigned long,
 693                                                     int, int, int,
 694                                                     void *),
 695                                            void *))
 696 {
 697   exec_ops.to_find_memory_regions = func;
 698 }
 699
 700 static char *exec_make_note_section (bfd *, int *);
 701
 702 /* Fill in the exec file target vector.  Very few entries need to be
 703    defined.  */
 704
 705 static void
 706 init_exec_ops (void)
 707 {
 708   exec_ops.to_shortname = "exec";
 709   exec_ops.to_longname = "Local exec file";
 710   exec_ops.to_doc = "Use an executable file as a target.\n\
 711 Specify the filename of the executable file.";
 712   exec_ops.to_open = exec_open;
 713   exec_ops.to_close = exec_close;
 714   exec_ops.to_attach = find_default_attach;
 715   exec_ops.to_require_attach = find_default_require_attach;
 716   exec_ops.to_require_detach = find_default_require_detach;
 717   exec_ops.to_xfer_memory = xfer_memory;
 718   exec_ops.to_files_info = exec_files_info;
 719   exec_ops.to_insert_breakpoint = ignore;
 720   exec_ops.to_remove_breakpoint = ignore;
 721   exec_ops.to_create_inferior = find_default_create_inferior;
 722   exec_ops.to_clone_and_follow_inferior = find_default_clone_and_follow_inferior;
 723   exec_ops.to_stratum = file_stratum;
 724   exec_ops.to_has_memory = 1;
 725   exec_ops.to_make_corefile_notes = exec_make_note_section;
 726   exec_ops.to_magic = OPS_MAGIC;
 727 }
 728
 729 void
 730 _initialize_exec (void)
 731 {
 732   struct cmd_list_element *c;
 733
 734   init_exec_ops ();
 735
 736   if (!dbx_commands)
 737     {
 738       c = add_cmd ("file", class_files, file_command,
 739                    "Use FILE as program to be debugged.\n\
 740 It is read for its symbols, for getting the contents of pure memory,\n\
 741 and it is the program executed when you use the `run' command.\n\
 742 If FILE cannot be found as specified, your execution directory path\n\
 743 ($PATH) is searched for a command of that name.\n\
 744 No arg means to have no executable file and no symbols.", &cmdlist);
 745       c->completer = filename_completer;
 746     }
 747
 748   c = add_cmd ("exec-file", class_files, exec_file_command,
 749                "Use FILE as program for getting contents of pure memory.\n\
 750 If FILE cannot be found as specified, your execution directory path\n\
 751 is searched for a command of that name.\n\
 752 No arg means have no executable file.", &cmdlist);
 753   c->completer = filename_completer;
 754
 755   add_com ("section", class_files, set_section_command,
 756            "Change the base address of section SECTION of the exec file to ADDR.\n\
 757 This can be used if the exec file does not contain section addresses,\n\
 758 (such as in the a.out format), or when the addresses specified in the\n\
 759 file itself are wrong.  Each section must be changed separately.  The\n\
 760 ``info files'' command lists all the sections and their addresses.");
 761
 762   add_show_from_set
 763     (add_set_cmd ("write", class_support, var_boolean, (char *) &write_files,
 764                   "Set writing into executable and core files.",
 765                   &setlist),
 766      &showlist);
 767
 768   add_target (&exec_ops);
 769 }
 770
 771 static char *
 772 exec_make_note_section (bfd *obfd, int *note_size)
 773 {
 774   struct cleanup *old_chain;
 775   char fname[16] = {'\0'};
 776   char psargs[80] = {'\0'};
 777   char *note_data = NULL;
 778
 779   if (get_exec_file (0))
 780     {
 781       strncpy (fname, strrchr (get_exec_file (0), '/') + 1, sizeof (fname));
 782       strncpy (psargs, get_exec_file (0),
 783                sizeof (psargs));
 784       if (get_inferior_args ())
 785         {
 786           strncat (psargs, " ",
 787                    sizeof (psargs) - strlen (psargs));
 788           strncat (psargs, get_inferior_args (),
 789                    sizeof (psargs) - strlen (psargs));
 790         }
 791
 792       note_data = (char *) elfcore_write_prpsinfo (obfd,
 793                                                    note_data,
 794                                                    note_size,
 795                                                    fname,
 796                                                    psargs);
 797       make_cleanup (xfree, note_data);
 798     }
 799   return note_data;
 800 }