gdb/exec.c

   1 /* Work with executable files, for GDB.
   2    Copyright 1988, 1989, 1991, 1992 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  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
  27 #ifdef USG
  28 #include <sys/types.h>
  29 #endif
  30
  31 #include <sys/param.h>
  32 #include <fcntl.h>
  33 #include <string.h>
  34
  35 #include "gdbcore.h"
  36
  37 #include <ctype.h>
  38 #include <sys/stat.h>
  39 #ifndef O_BINARY
  40 #define O_BINARY 0
  41 #endif
  42
  43 /* Prototypes for local functions */
  44
  45 static void
  46 add_to_section_table PARAMS ((bfd *, sec_ptr, PTR));
  47
  48 static void
  49 exec_close PARAMS ((int));
  50
  51 static void
  52 file_command PARAMS ((char *, int));
  53
  54 static void
  55 set_section_command PARAMS ((char *, int));
  56
  57 static void
  58 exec_files_info PARAMS ((struct target_ops *));
  59
  60 extern int info_verbose;
  61
  62 /* The Binary File Descriptor handle for the executable file.  */
  63
  64 bfd *exec_bfd = NULL;
  65
  66 /* Whether to open exec and core files read-only or read-write.  */
  67
  68 int write_files = 0;
  69
  70 /* Text start and end addresses (KLUDGE) if needed */
  71
  72 #ifdef NEED_TEXT_START_END
  73 CORE_ADDR text_start = 0;
  74 CORE_ADDR text_end   = 0;
  75 #endif
  76
  77 /* Forward decl */
  78
  79 extern struct target_ops exec_ops;
  80
  81 /* ARGSUSED */
  82 static void
  83 exec_close (quitting)
  84      int quitting;
  85 {
  86   if (exec_bfd) {
  87     char *name = bfd_get_filename (exec_bfd);
  88     bfd_close (exec_bfd);
  89     free (name);
  90     exec_bfd = NULL;
  91   }
  92   if (exec_ops.to_sections) {
  93     free ((PTR)exec_ops.to_sections);
  94     exec_ops.to_sections = NULL;
  95     exec_ops.to_sections_end = NULL;
  96   }
  97 }
  98
  99 /*  Process the first arg in ARGS as the new exec file.
 100
 101     Note that we have to explicitly ignore additional args, since we can
 102     be called from file_command(), which also calls symbol_file_command()
 103     which can take multiple args. */
 104
 105 void
 106 exec_file_command (args, from_tty)
 107      char *args;
 108      int from_tty;
 109 {
 110   char **argv;
 111   char *filename;
 112
 113   target_preopen (from_tty);
 114
 115   /* Remove any previous exec file.  */
 116   unpush_target (&exec_ops);
 117
 118   /* Now open and digest the file the user requested, if any.  */
 119
 120   if (args)
 121     {
 122       char *scratch_pathname;
 123       int scratch_chan;
 124
 125       /* Scan through the args and pick up the first non option arg
 126          as the filename. */
 127
 128       if ((argv = buildargv (args)) == NULL)
 129         {
 130           nomem (0);
 131         }
 132       make_cleanup (freeargv, (char *) argv);
 133
 134       for (; (*argv != NULL) && (**argv == '-'); argv++) {;}
 135       if (*argv == NULL)
 136         {
 137           error ("no exec file name was specified");
 138         }
 139
 140       filename = tilde_expand (*argv);
 141       make_cleanup (free, filename);
 142
 143       scratch_chan = openp (getenv ("PATH"), 1, filename,
 144                             write_files? O_RDWR|O_BINARY: O_RDONLY|O_BINARY, 0,
 145                             &scratch_pathname);
 146       if (scratch_chan < 0)
 147         perror_with_name (filename);
 148
 149       exec_bfd = bfd_fdopenr (scratch_pathname, gnutarget, scratch_chan);
 150       if (!exec_bfd)
 151         error ("Could not open `%s' as an executable file: %s",
 152                scratch_pathname, bfd_errmsg (bfd_error));
 153       if (!bfd_check_format (exec_bfd, bfd_object))
 154         {
 155           /* Make sure to close exec_bfd, or else "run" might try to use
 156              it.  */
 157           exec_close (0);
 158           error ("\"%s\": not in executable format: %s.",
 159                  scratch_pathname, bfd_errmsg (bfd_error));
 160         }
 161
 162       if (build_section_table (exec_bfd, &exec_ops.to_sections,
 163                                 &exec_ops.to_sections_end))
 164         {
 165           /* Make sure to close exec_bfd, or else "run" might try to use
 166              it.  */
 167           exec_close (0);
 168           error ("Can't find the file sections in `%s': %s",
 169                  exec_bfd->filename, bfd_errmsg (bfd_error));
 170         }
 171
 172 #ifdef NEED_TEXT_START_END
 173
 174       /* text_end is sometimes used for where to put call dummies.  A
 175          few ports use these for other purposes too.  */
 176
 177       {
 178         struct section_table *p;
 179
 180         /* Set text_start to the lowest address of the start of any
 181            readonly code section and set text_end to the highest
 182            address of the end of any readonly code section.  */
 183
 184         text_start = ~(CORE_ADDR)0;
 185         text_end = (CORE_ADDR)0;
 186         for (p = exec_ops.to_sections; p < exec_ops.to_sections_end; p++)
 187           if (bfd_get_section_flags (p->bfd, p->sec_ptr)
 188               & (SEC_CODE | SEC_READONLY))
 189             {
 190               if (text_start > p->addr)
 191                 text_start = p->addr;
 192               if (text_end < p->endaddr)
 193                 text_end = p->endaddr;
 194             }
 195       }
 196 #endif
 197
 198       validate_files ();
 199
 200       push_target (&exec_ops);
 201
 202       /* Tell display code (if any) about the changed file name.  */
 203       if (exec_file_display_hook)
 204         (*exec_file_display_hook) (filename);
 205     }
 206   else if (from_tty)
 207     printf_unfiltered ("No exec file now.\n");
 208 }
 209
 210 /* Set both the exec file and the symbol file, in one command.
 211    What a novelty.  Why did GDB go through four major releases before this
 212    command was added?  */
 213
 214 static void
 215 file_command (arg, from_tty)
 216      char *arg;
 217      int from_tty;
 218 {
 219   /* FIXME, if we lose on reading the symbol file, we should revert
 220      the exec file, but that's rough.  */
 221   exec_file_command (arg, from_tty);
 222   symbol_file_command (arg, from_tty);
 223 }
 224
 225 \f
 226 /* Locate all mappable sections of a BFD file.
 227    table_pp_char is a char * to get it through bfd_map_over_sections;
 228    we cast it back to its proper type.  */
 229
 230 static void
 231 add_to_section_table (abfd, asect, table_pp_char)
 232      bfd *abfd;
 233      sec_ptr asect;
 234      PTR table_pp_char;
 235 {
 236   struct section_table **table_pp = (struct section_table **)table_pp_char;
 237   flagword aflag;
 238
 239   aflag = bfd_get_section_flags (abfd, asect);
 240   /* FIXME, we need to handle BSS segment here...it alloc's but doesn't load */
 241   if (!(aflag & SEC_LOAD))
 242     return;
 243   if (0 == bfd_section_size (abfd, asect))
 244     return;
 245   (*table_pp)->bfd = abfd;
 246   (*table_pp)->sec_ptr = asect;
 247   (*table_pp)->addr = bfd_section_vma (abfd, asect);
 248   (*table_pp)->endaddr = (*table_pp)->addr + bfd_section_size (abfd, asect);
 249   (*table_pp)++;
 250 }
 251
 252 /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
 253    Returns 0 if OK, 1 on error.  */
 254
 255 int
 256 build_section_table (some_bfd, start, end)
 257      bfd *some_bfd;
 258      struct section_table **start, **end;
 259 {
 260   unsigned count;
 261
 262   count = bfd_count_sections (some_bfd);
 263   if (*start)
 264     free ((PTR)*start);
 265   *start = (struct section_table *) xmalloc (count * sizeof (**start));
 266   *end = *start;
 267   bfd_map_over_sections (some_bfd, add_to_section_table, (char *)end);
 268   if (*end > *start + count)
 269     abort();
 270   /* We could realloc the table, but it probably loses for most files.  */
 271   return 0;
 272 }
 273 \f
 274 /* Read or write the exec file.
 275
 276    Args are address within a BFD file, address within gdb address-space,
 277    length, and a flag indicating whether to read or write.
 278
 279    Result is a length:
 280
 281         0:    We cannot handle this address and length.
 282         > 0:  We have handled N bytes starting at this address.
 283               (If N == length, we did it all.)  We might be able
 284               to handle more bytes beyond this length, but no
 285               promises.
 286         < 0:  We cannot handle this address, but if somebody
 287               else handles (-N) bytes, we can start from there.
 288
 289     The same routine is used to handle both core and exec files;
 290     we just tail-call it with more arguments to select between them.  */
 291
 292 int
 293 xfer_memory (memaddr, myaddr, len, write, target)
 294      CORE_ADDR memaddr;
 295      char *myaddr;
 296      int len;
 297      int write;
 298      struct target_ops *target;
 299 {
 300   boolean res;
 301   struct section_table *p;
 302   CORE_ADDR nextsectaddr, memend;
 303   boolean (*xfer_fn) PARAMS ((bfd *, sec_ptr, PTR, file_ptr, bfd_size_type));
 304
 305   if (len <= 0)
 306     abort();
 307
 308   memend = memaddr + len;
 309   xfer_fn = write? bfd_set_section_contents: bfd_get_section_contents;
 310   nextsectaddr = memend;
 311
 312   for (p = target->to_sections; p < target->to_sections_end; p++)
 313     {
 314       if (p->addr <= memaddr)
 315         if (p->endaddr >= memend)
 316           {
 317             /* Entire transfer is within this section.  */
 318             res = xfer_fn (p->bfd, p->sec_ptr, myaddr, memaddr - p->addr, len);
 319             return (res != false)? len: 0;
 320           }
 321         else if (p->endaddr <= memaddr)
 322           {
 323             /* This section ends before the transfer starts.  */
 324             continue;
 325           }
 326         else
 327           {
 328             /* This section overlaps the transfer.  Just do half.  */
 329             len = p->endaddr - memaddr;
 330             res = xfer_fn (p->bfd, p->sec_ptr, myaddr, memaddr - p->addr, len);
 331             return (res != false)? len: 0;
 332           }
 333       else if (p->addr < nextsectaddr)
 334         nextsectaddr = p->addr;
 335     }
 336
 337   if (nextsectaddr >= memend)
 338     return 0;                           /* We can't help */
 339   else
 340     return - (nextsectaddr - memaddr);  /* Next boundary where we can help */
 341 }
 342
 343 #ifdef FIXME
 344 #ifdef REG_STACK_SEGMENT
 345 /* MOVE TO BFD... */
 346     /* Pyramids and AM29000s have an extra segment in the virtual address space
 347        for the (control) stack of register-window frames.  The AM29000 folk
 348        call it the "register stack" rather than the "memory stack".  */
 349     else if (memaddr >= reg_stack_start && memaddr < reg_stack_end)
 350       {
 351         i = min (len, reg_stack_end - memaddr);
 352         fileptr = memaddr - reg_stack_start + reg_stack_offset;
 353         wanna_xfer = coredata;
 354       }
 355 #endif                          /* REG_STACK_SEGMENT */
 356 #endif /* FIXME */
 357 \f
 358 void
 359 print_section_info (t, abfd)
 360   struct target_ops *t;
 361   bfd *abfd;
 362 {
 363   struct section_table *p;
 364
 365   printf_filtered ("\t`%s', ", bfd_get_filename(abfd));
 366   wrap_here ("        ");
 367   printf_filtered ("file type %s.\n", bfd_get_target(abfd));
 368   printf_filtered ("\tEntry point: %s\n",
 369                    local_hex_string ((unsigned long) bfd_get_start_address (exec_bfd)));
 370   for (p = t->to_sections; p < t->to_sections_end; p++) {
 371     printf_filtered ("\t%s", local_hex_string_custom ((unsigned long) p->addr, "08l"));
 372     printf_filtered (" - %s", local_hex_string_custom ((unsigned long) p->endaddr, "08l"));
 373     if (info_verbose)
 374       printf_filtered (" @ %s",
 375                        local_hex_string_custom ((unsigned long) p->sec_ptr->filepos, "08l"));
 376     printf_filtered (" is %s", bfd_section_name (p->bfd, p->sec_ptr));
 377     if (p->bfd != abfd) {
 378       printf_filtered (" in %s", bfd_get_filename (p->bfd));
 379     }
 380     printf_filtered ("\n");
 381   }
 382 }
 383
 384 static void
 385 exec_files_info (t)
 386   struct target_ops *t;
 387 {
 388   print_section_info (t, exec_bfd);
 389 }
 390
 391 static void
 392 set_section_command (args, from_tty)
 393      char *args;
 394      int from_tty;
 395 {
 396   struct section_table *p;
 397   char *secname;
 398   unsigned seclen;
 399   unsigned long secaddr;
 400   char secprint[100];
 401   long offset;
 402
 403   if (args == 0)
 404     error ("Must specify section name and its virtual address");
 405
 406   /* Parse out section name */
 407   for (secname = args; !isspace(*args); args++) ;
 408   seclen = args - secname;
 409
 410   /* Parse out new virtual address */
 411   secaddr = parse_and_eval_address (args);
 412
 413   for (p = exec_ops.to_sections; p < exec_ops.to_sections_end; p++) {
 414     if (!strncmp (secname, bfd_section_name (exec_bfd, p->sec_ptr), seclen)
 415         && bfd_section_name (exec_bfd, p->sec_ptr)[seclen] == '\0') {
 416       offset = secaddr - p->addr;
 417       p->addr += offset;
 418       p->endaddr += offset;
 419       if (from_tty)
 420         exec_files_info(&exec_ops);
 421       return;
 422     }
 423   }
 424   if (seclen >= sizeof (secprint))
 425     seclen = sizeof (secprint) - 1;
 426   strncpy (secprint, secname, seclen);
 427   secprint[seclen] = '\0';
 428   error ("Section %s not found", secprint);
 429 }
 430
 431 /* If mourn is being called in all the right places, this could be say
 432    `gdb internal error' (since generic_mourn calls breakpoint_init_inferior).  */
 433
 434 static int
 435 ignore (addr, contents)
 436      CORE_ADDR addr;
 437      char *contents;
 438 {
 439   return 0;
 440 }
 441
 442 struct target_ops exec_ops = {
 443         "exec", "Local exec file",
 444         "Use an executable file as a target.\n\
 445 Specify the filename of the executable file.",
 446         exec_file_command, exec_close, /* open, close */
 447         find_default_attach, 0, 0, 0, /* attach, detach, resume, wait, */
 448         0, 0, /* fetch_registers, store_registers, */
 449         0, /* prepare_to_store, */
 450         xfer_memory, exec_files_info,
 451         ignore, ignore, /* insert_breakpoint, remove_breakpoint, */
 452         0, 0, 0, 0, 0, /* terminal stuff */
 453         0, 0, /* kill, load */
 454         0, /* lookup sym */
 455         find_default_create_inferior,
 456         0, /* mourn_inferior */
 457         0, /* can_run */
 458         0, /* notice_signals */
 459         file_stratum, 0, /* next */
 460         0, 1, 0, 0, 0,  /* all mem, mem, stack, regs, exec */
 461         0, 0,                   /* section pointers */
 462         OPS_MAGIC,              /* Always the last thing */
 463 };
 464
 465 void
 466 _initialize_exec()
 467 {
 468   struct cmd_list_element *c;
 469
 470   c = add_cmd ("file", class_files, file_command,
 471                "Use FILE as program to be debugged.\n\
 472 It is read for its symbols, for getting the contents of pure memory,\n\
 473 and it is the program executed when you use the `run' command.\n\
 474 If FILE cannot be found as specified, your execution directory path\n\
 475 ($PATH) is searched for a command of that name.\n\
 476 No arg means to have no executable file and no symbols.", &cmdlist);
 477   c->completer = filename_completer;
 478
 479   c = add_cmd ("exec-file", class_files, exec_file_command,
 480            "Use FILE as program for getting contents of pure memory.\n\
 481 If FILE cannot be found as specified, your execution directory path\n\
 482 is searched for a command of that name.\n\
 483 No arg means have no executable file.", &cmdlist);
 484   c->completer = filename_completer;
 485
 486   add_com ("section", class_files, set_section_command,
 487    "Change the base address of section SECTION of the exec file to ADDR.\n\
 488 This can be used if the exec file does not contain section addresses,\n\
 489 (such as in the a.out format), or when the addresses specified in the\n\
 490 file itself are wrong.  Each section must be changed separately.  The\n\
 491 ``info files'' command lists all the sections and their addresses.");
 492
 493   add_show_from_set
 494     (add_set_cmd ("write", class_support, var_boolean, (char *)&write_files,
 495                   "Set writing into executable and core files.",
 496                   &setlist),
 497      &showlist);
 498
 499   add_target (&exec_ops);
 500 }