gdb/symfile.c

   1 /* Generic symbol file reading for the GNU debugger, GDB.
   2    Copyright 1990-1996, 1998, 2000 Free Software Foundation, Inc.
   3    Contributed by Cygnus Support, using pieces from other GDB modules.
   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 2 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, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23 #include "symtab.h"
  24 #include "gdbtypes.h"
  25 #include "gdbcore.h"
  26 #include "frame.h"
  27 #include "target.h"
  28 #include "value.h"
  29 #include "symfile.h"
  30 #include "objfiles.h"
  31 #include "gdbcmd.h"
  32 #include "breakpoint.h"
  33 #include "language.h"
  34 #include "complaints.h"
  35 #include "demangle.h"
  36 #include "inferior.h"           /* for write_pc */
  37 #include "gdb-stabs.h"
  38 #include "obstack.h"
  39
  40 #include <assert.h>
  41 #include <sys/types.h>
  42 #include <fcntl.h>
  43 #include "gdb_string.h"
  44 #include "gdb_stat.h"
  45 #include <ctype.h>
  46 #include <time.h>
  47
  48 #ifndef O_BINARY
  49 #define O_BINARY 0
  50 #endif
  51
  52 #ifdef HPUXHPPA
  53
  54 /* Some HP-UX related globals to clear when a new "main"
  55    symbol file is loaded. HP-specific.  */
  56
  57 extern int hp_som_som_object_present;
  58 extern int hp_cxx_exception_support_initialized;
  59 #define RESET_HP_UX_GLOBALS() do {\
  60                                     hp_som_som_object_present = 0;             /* indicates HP-compiled code */        \
  61                                     hp_cxx_exception_support_initialized = 0;  /* must reinitialize exception stuff */ \
  62                               } while (0)
  63 #endif
  64
  65 int (*ui_load_progress_hook) (const char *section, unsigned long num);
  66 void (*show_load_progress) (const char *section,
  67                             unsigned long section_sent,
  68                             unsigned long section_size,
  69                             unsigned long total_sent,
  70                             unsigned long total_size);
  71 void (*pre_add_symbol_hook) (char *);
  72 void (*post_add_symbol_hook) (void);
  73 void (*target_new_objfile_hook) (struct objfile *);
  74
  75 static void clear_symtab_users_cleanup (void *ignore);
  76
  77 /* Global variables owned by this file */
  78 int readnow_symbol_files;       /* Read full symbols immediately */
  79
  80 struct complaint oldsyms_complaint =
  81 {
  82   "Replacing old symbols for `%s'", 0, 0
  83 };
  84
  85 struct complaint empty_symtab_complaint =
  86 {
  87   "Empty symbol table found for `%s'", 0, 0
  88 };
  89
  90 struct complaint unknown_option_complaint =
  91 {
  92   "Unknown option `%s' ignored", 0, 0
  93 };
  94
  95 /* External variables and functions referenced. */
  96
  97 extern int info_verbose;
  98
  99 extern void report_transfer_performance (unsigned long, time_t, time_t);
 100
 101 /* Functions this file defines */
 102
 103 #if 0
 104 static int simple_read_overlay_region_table (void);
 105 static void simple_free_overlay_region_table (void);
 106 #endif
 107
 108 static void set_initial_language (void);
 109
 110 static void load_command (char *, int);
 111
 112 static void add_symbol_file_command (char *, int);
 113
 114 static void add_shared_symbol_files_command (char *, int);
 115
 116 static void cashier_psymtab (struct partial_symtab *);
 117
 118 static int compare_psymbols (const void *, const void *);
 119
 120 static int compare_symbols (const void *, const void *);
 121
 122 bfd *symfile_bfd_open (char *);
 123
 124 static void find_sym_fns (struct objfile *);
 125
 126 static void decrement_reading_symtab (void *);
 127
 128 static void overlay_invalidate_all (void);
 129
 130 static int overlay_is_mapped (struct obj_section *);
 131
 132 void list_overlays_command (char *, int);
 133
 134 void map_overlay_command (char *, int);
 135
 136 void unmap_overlay_command (char *, int);
 137
 138 static void overlay_auto_command (char *, int);
 139
 140 static void overlay_manual_command (char *, int);
 141
 142 static void overlay_off_command (char *, int);
 143
 144 static void overlay_load_command (char *, int);
 145
 146 static void overlay_command (char *, int);
 147
 148 static void simple_free_overlay_table (void);
 149
 150 static void read_target_long_array (CORE_ADDR, unsigned int *, int);
 151
 152 static int simple_read_overlay_table (void);
 153
 154 static int simple_overlay_update_1 (struct obj_section *);
 155
 156 static void add_filename_language (char *ext, enum language lang);
 157
 158 static void set_ext_lang_command (char *args, int from_tty);
 159
 160 static void info_ext_lang_command (char *args, int from_tty);
 161
 162 static void init_filename_language_table (void);
 163
 164 void _initialize_symfile (void);
 165
 166 /* List of all available sym_fns.  On gdb startup, each object file reader
 167    calls add_symtab_fns() to register information on each format it is
 168    prepared to read. */
 169
 170 static struct sym_fns *symtab_fns = NULL;
 171
 172 /* Flag for whether user will be reloading symbols multiple times.
 173    Defaults to ON for VxWorks, otherwise OFF.  */
 174
 175 #ifdef SYMBOL_RELOADING_DEFAULT
 176 int symbol_reloading = SYMBOL_RELOADING_DEFAULT;
 177 #else
 178 int symbol_reloading = 0;
 179 #endif
 180
 181 /* If non-zero, then on HP-UX (i.e., platforms that use somsolib.c),
 182    this variable is interpreted as a threshhold.  If adding a new
 183    library's symbol table to those already known to the debugger would
 184    exceed this threshhold, then the shlib's symbols are not added.
 185
 186    If non-zero on other platforms, shared library symbols will be added
 187    automatically when the inferior is created, new libraries are loaded,
 188    or when attaching to the inferior.  This is almost always what users
 189    will want to have happen; but for very large programs, the startup
 190    time will be excessive, and so if this is a problem, the user can
 191    clear this flag and then add the shared library symbols as needed.
 192    Note that there is a potential for confusion, since if the shared
 193    library symbols are not loaded, commands like "info fun" will *not*
 194    report all the functions that are actually present.
 195
 196    Note that HP-UX interprets this variable to mean, "threshhold size
 197    in megabytes, where zero means never add".  Other platforms interpret
 198    this variable to mean, "always add if non-zero, never add if zero."
 199  */
 200
 201 int auto_solib_add = 1;
 202 \f
 203
 204 /* Since this function is called from within qsort, in an ANSI environment
 205    it must conform to the prototype for qsort, which specifies that the
 206    comparison function takes two "void *" pointers. */
 207
 208 static int
 209 compare_symbols (s1p, s2p)
 210      const PTR s1p;
 211      const PTR s2p;
 212 {
 213   register struct symbol **s1, **s2;
 214
 215   s1 = (struct symbol **) s1p;
 216   s2 = (struct symbol **) s2p;
 217
 218   return (STRCMP (SYMBOL_NAME (*s1), SYMBOL_NAME (*s2)));
 219 }
 220
 221 /*
 222
 223    LOCAL FUNCTION
 224
 225    compare_psymbols -- compare two partial symbols by name
 226
 227    DESCRIPTION
 228
 229    Given pointers to pointers to two partial symbol table entries,
 230    compare them by name and return -N, 0, or +N (ala strcmp).
 231    Typically used by sorting routines like qsort().
 232
 233    NOTES
 234
 235    Does direct compare of first two characters before punting
 236    and passing to strcmp for longer compares.  Note that the
 237    original version had a bug whereby two null strings or two
 238    identically named one character strings would return the
 239    comparison of memory following the null byte.
 240
 241  */
 242
 243 static int
 244 compare_psymbols (s1p, s2p)
 245      const PTR s1p;
 246      const PTR s2p;
 247 {
 248   register char *st1 = SYMBOL_NAME (*(struct partial_symbol **) s1p);
 249   register char *st2 = SYMBOL_NAME (*(struct partial_symbol **) s2p);
 250
 251   if ((st1[0] - st2[0]) || !st1[0])
 252     {
 253       return (st1[0] - st2[0]);
 254     }
 255   else if ((st1[1] - st2[1]) || !st1[1])
 256     {
 257       return (st1[1] - st2[1]);
 258     }
 259   else
 260     {
 261       /* Note: I replaced the STRCMP line (commented out below)
 262        * with a simpler "strcmp()" which compares the 2 strings
 263        * from the beginning. (STRCMP is a macro which first compares
 264        * the initial characters, then falls back on strcmp).
 265        * The reason is that the STRCMP line was tickling a C compiler
 266        * bug on HP-UX 10.30, which is avoided with the simpler
 267        * code. The performance gain from the more complicated code
 268        * is negligible, given that we have already checked the
 269        * initial 2 characters above. I reported the compiler bug,
 270        * and once it is fixed the original line can be put back. RT
 271        */
 272       /* return ( STRCMP (st1 + 2, st2 + 2)); */
 273       return (strcmp (st1, st2));
 274     }
 275 }
 276
 277 void
 278 sort_pst_symbols (pst)
 279      struct partial_symtab *pst;
 280 {
 281   /* Sort the global list; don't sort the static list */
 282
 283   qsort (pst->objfile->global_psymbols.list + pst->globals_offset,
 284          pst->n_global_syms, sizeof (struct partial_symbol *),
 285          compare_psymbols);
 286 }
 287
 288 /* Call sort_block_syms to sort alphabetically the symbols of one block.  */
 289
 290 void
 291 sort_block_syms (b)
 292      register struct block *b;
 293 {
 294   qsort (&BLOCK_SYM (b, 0), BLOCK_NSYMS (b),
 295          sizeof (struct symbol *), compare_symbols);
 296 }
 297
 298 /* Call sort_symtab_syms to sort alphabetically
 299    the symbols of each block of one symtab.  */
 300
 301 void
 302 sort_symtab_syms (s)
 303      register struct symtab *s;
 304 {
 305   register struct blockvector *bv;
 306   int nbl;
 307   int i;
 308   register struct block *b;
 309
 310   if (s == 0)
 311     return;
 312   bv = BLOCKVECTOR (s);
 313   nbl = BLOCKVECTOR_NBLOCKS (bv);
 314   for (i = 0; i < nbl; i++)
 315     {
 316       b = BLOCKVECTOR_BLOCK (bv, i);
 317       if (BLOCK_SHOULD_SORT (b))
 318         sort_block_syms (b);
 319     }
 320 }
 321
 322 /* Make a null terminated copy of the string at PTR with SIZE characters in
 323    the obstack pointed to by OBSTACKP .  Returns the address of the copy.
 324    Note that the string at PTR does not have to be null terminated, I.E. it
 325    may be part of a larger string and we are only saving a substring. */
 326
 327 char *
 328 obsavestring (ptr, size, obstackp)
 329      char *ptr;
 330      int size;
 331      struct obstack *obstackp;
 332 {
 333   register char *p = (char *) obstack_alloc (obstackp, size + 1);
 334   /* Open-coded memcpy--saves function call time.  These strings are usually
 335      short.  FIXME: Is this really still true with a compiler that can
 336      inline memcpy? */
 337   {
 338     register char *p1 = ptr;
 339     register char *p2 = p;
 340     char *end = ptr + size;
 341     while (p1 != end)
 342       *p2++ = *p1++;
 343   }
 344   p[size] = 0;
 345   return p;
 346 }
 347
 348 /* Concatenate strings S1, S2 and S3; return the new string.  Space is found
 349    in the obstack pointed to by OBSTACKP.  */
 350
 351 char *
 352 obconcat (obstackp, s1, s2, s3)
 353      struct obstack *obstackp;
 354      const char *s1, *s2, *s3;
 355 {
 356   register int len = strlen (s1) + strlen (s2) + strlen (s3) + 1;
 357   register char *val = (char *) obstack_alloc (obstackp, len);
 358   strcpy (val, s1);
 359   strcat (val, s2);
 360   strcat (val, s3);
 361   return val;
 362 }
 363
 364 /* True if we are nested inside psymtab_to_symtab. */
 365
 366 int currently_reading_symtab = 0;
 367
 368 static void
 369 decrement_reading_symtab (dummy)
 370      void *dummy;
 371 {
 372   currently_reading_symtab--;
 373 }
 374
 375 /* Get the symbol table that corresponds to a partial_symtab.
 376    This is fast after the first time you do it.  In fact, there
 377    is an even faster macro PSYMTAB_TO_SYMTAB that does the fast
 378    case inline.  */
 379
 380 struct symtab *
 381 psymtab_to_symtab (pst)
 382      register struct partial_symtab *pst;
 383 {
 384   /* If it's been looked up before, return it. */
 385   if (pst->symtab)
 386     return pst->symtab;
 387
 388   /* If it has not yet been read in, read it.  */
 389   if (!pst->readin)
 390     {
 391       struct cleanup *back_to = make_cleanup (decrement_reading_symtab, NULL);
 392       currently_reading_symtab++;
 393       (*pst->read_symtab) (pst);
 394       do_cleanups (back_to);
 395     }
 396
 397   return pst->symtab;
 398 }
 399
 400 /* Initialize entry point information for this objfile. */
 401
 402 void
 403 init_entry_point_info (objfile)
 404      struct objfile *objfile;
 405 {
 406   /* Save startup file's range of PC addresses to help blockframe.c
 407      decide where the bottom of the stack is.  */
 408
 409   if (bfd_get_file_flags (objfile->obfd) & EXEC_P)
 410     {
 411       /* Executable file -- record its entry point so we'll recognize
 412          the startup file because it contains the entry point.  */
 413       objfile->ei.entry_point = bfd_get_start_address (objfile->obfd);
 414     }
 415   else
 416     {
 417       /* Examination of non-executable.o files.  Short-circuit this stuff.  */
 418       objfile->ei.entry_point = INVALID_ENTRY_POINT;
 419     }
 420   objfile->ei.entry_file_lowpc = INVALID_ENTRY_LOWPC;
 421   objfile->ei.entry_file_highpc = INVALID_ENTRY_HIGHPC;
 422   objfile->ei.entry_func_lowpc = INVALID_ENTRY_LOWPC;
 423   objfile->ei.entry_func_highpc = INVALID_ENTRY_HIGHPC;
 424   objfile->ei.main_func_lowpc = INVALID_ENTRY_LOWPC;
 425   objfile->ei.main_func_highpc = INVALID_ENTRY_HIGHPC;
 426 }
 427
 428 /* Get current entry point address.  */
 429
 430 CORE_ADDR
 431 entry_point_address ()
 432 {
 433   return symfile_objfile ? symfile_objfile->ei.entry_point : 0;
 434 }
 435
 436 /* Remember the lowest-addressed loadable section we've seen.
 437    This function is called via bfd_map_over_sections.
 438
 439    In case of equal vmas, the section with the largest size becomes the
 440    lowest-addressed loadable section.
 441
 442    If the vmas and sizes are equal, the last section is considered the
 443    lowest-addressed loadable section.  */
 444
 445 void
 446 find_lowest_section (abfd, sect, obj)
 447      bfd *abfd;
 448      asection *sect;
 449      PTR obj;
 450 {
 451   asection **lowest = (asection **) obj;
 452
 453   if (0 == (bfd_get_section_flags (abfd, sect) & SEC_LOAD))
 454     return;
 455   if (!*lowest)
 456     *lowest = sect;             /* First loadable section */
 457   else if (bfd_section_vma (abfd, *lowest) > bfd_section_vma (abfd, sect))
 458     *lowest = sect;             /* A lower loadable section */
 459   else if (bfd_section_vma (abfd, *lowest) == bfd_section_vma (abfd, sect)
 460            && (bfd_section_size (abfd, (*lowest))
 461                <= bfd_section_size (abfd, sect)))
 462     *lowest = sect;
 463 }
 464
 465
 466 /* Build (allocate and populate) a section_addr_info struct from
 467    an existing section table. */
 468
 469 extern struct section_addr_info *
 470 build_section_addr_info_from_section_table (const struct section_table *start,
 471                                             const struct section_table *end)
 472 {
 473   struct section_addr_info *sap;
 474   const struct section_table *stp;
 475   int oidx;
 476
 477   sap = xmalloc (sizeof (struct section_addr_info));
 478   memset (sap, 0, sizeof (struct section_addr_info));
 479
 480   for (stp = start, oidx = 0; stp != end; stp++)
 481     {
 482       if (stp->the_bfd_section->flags & (SEC_ALLOC | SEC_LOAD)
 483           && oidx < MAX_SECTIONS)
 484         {
 485           sap->other[oidx].addr = stp->addr;
 486           sap->other[oidx].name = xstrdup (stp->the_bfd_section->name);
 487           sap->other[oidx].sectindex = stp->the_bfd_section->index;
 488           oidx++;
 489         }
 490     }
 491
 492   return sap;
 493 }
 494
 495
 496 /* Free all memory allocated by build_section_addr_info_from_section_table. */
 497
 498 extern void
 499 free_section_addr_info (struct section_addr_info *sap)
 500 {
 501   int idx;
 502
 503   for (idx = 0; idx < MAX_SECTIONS; idx++)
 504     if (sap->other[idx].name)
 505       free (sap->other[idx].name);
 506   free (sap);
 507 }
 508
 509
 510 /* Parse the user's idea of an offset for dynamic linking, into our idea
 511    of how to represent it for fast symbol reading.  This is the default
 512    version of the sym_fns.sym_offsets function for symbol readers that
 513    don't need to do anything special.  It allocates a section_offsets table
 514    for the objectfile OBJFILE and stuffs ADDR into all of the offsets.  */
 515
 516 void
 517 default_symfile_offsets (objfile, addrs)
 518      struct objfile *objfile;
 519      struct section_addr_info *addrs;
 520 {
 521   int i;
 522   asection *sect = NULL;
 523
 524   objfile->num_sections = SECT_OFF_MAX;
 525   objfile->section_offsets = (struct section_offsets *)
 526     obstack_alloc (&objfile->psymbol_obstack, SIZEOF_SECTION_OFFSETS);
 527   memset (objfile->section_offsets, 0, SIZEOF_SECTION_OFFSETS);
 528
 529   /* Now calculate offsets for section that were specified by the
 530      caller. */
 531   for (i = 0; i < MAX_SECTIONS && addrs->other[i].name; i++)
 532     {
 533       struct other_sections *osp ;
 534
 535       osp = &addrs->other[i] ;
 536       if (osp->addr == 0)
 537         continue;
 538
 539       /* Record all sections in offsets */
 540       /* The section_offsets in the objfile are here filled in using
 541          the BFD index. */
 542       ANOFFSET (objfile->section_offsets, osp->sectindex) = osp->addr;
 543     }
 544
 545   /* Remember the bfd indexes for the .text, .data, .bss and
 546      .rodata sections. */
 547
 548   sect = bfd_get_section_by_name (objfile->obfd, ".text");
 549   if (sect)
 550     objfile->sect_index_text = sect->index;
 551
 552   sect = bfd_get_section_by_name (objfile->obfd, ".data");
 553   if (sect)
 554     objfile->sect_index_data = sect->index;
 555
 556   sect = bfd_get_section_by_name (objfile->obfd, ".bss");
 557   if (sect)
 558     objfile->sect_index_bss = sect->index;
 559
 560   sect = bfd_get_section_by_name (objfile->obfd, ".rodata");
 561   if (sect)
 562     objfile->sect_index_rodata = sect->index;
 563
 564 }
 565
 566 /* Process a symbol file, as either the main file or as a dynamically
 567    loaded file.
 568
 569    OBJFILE is where the symbols are to be read from.
 570
 571    ADDR is the address where the text segment was loaded, unless the
 572    objfile is the main symbol file, in which case it is zero.
 573
 574    MAINLINE is nonzero if this is the main symbol file, or zero if
 575    it's an extra symbol file such as dynamically loaded code.
 576
 577    VERBO is nonzero if the caller has printed a verbose message about
 578    the symbol reading (and complaints can be more terse about it).  */
 579
 580 void
 581 syms_from_objfile (objfile, addrs, mainline, verbo)
 582      struct objfile *objfile;
 583      struct section_addr_info *addrs;
 584      int mainline;
 585      int verbo;
 586 {
 587   asection *lower_sect;
 588   asection *sect;
 589   CORE_ADDR lower_offset;
 590   struct section_addr_info local_addr;
 591   struct cleanup *old_chain;
 592   int i;
 593
 594   /* If ADDRS is NULL, initialize the local section_addr_info struct and
 595      point ADDRS to it.  We now establish the convention that an addr of
 596      zero means no load address was specified. */
 597
 598   if (addrs == NULL)
 599     {
 600       memset (&local_addr, 0, sizeof (local_addr));
 601       addrs = &local_addr;
 602     }
 603
 604   init_entry_point_info (objfile);
 605   find_sym_fns (objfile);
 606
 607   /* Make sure that partially constructed symbol tables will be cleaned up
 608      if an error occurs during symbol reading.  */
 609   old_chain = make_cleanup_free_objfile (objfile);
 610
 611   if (mainline)
 612     {
 613       /* We will modify the main symbol table, make sure that all its users
 614          will be cleaned up if an error occurs during symbol reading.  */
 615       make_cleanup (clear_symtab_users_cleanup, 0 /*ignore*/);
 616
 617       /* Since no error yet, throw away the old symbol table.  */
 618
 619       if (symfile_objfile != NULL)
 620         {
 621           free_objfile (symfile_objfile);
 622           symfile_objfile = NULL;
 623         }
 624
 625       /* Currently we keep symbols from the add-symbol-file command.
 626          If the user wants to get rid of them, they should do "symbol-file"
 627          without arguments first.  Not sure this is the best behavior
 628          (PR 2207).  */
 629
 630       (*objfile->sf->sym_new_init) (objfile);
 631     }
 632
 633   /* Convert addr into an offset rather than an absolute address.
 634      We find the lowest address of a loaded segment in the objfile,
 635      and assume that <addr> is where that got loaded.
 636
 637      We no longer warn if the lowest section is not a text segment (as
 638      happens for the PA64 port.  */
 639   if (!mainline)
 640     {
 641       /* Find lowest loadable section to be used as starting point for
 642          continguous sections. FIXME!! won't work without call to find
 643          .text first, but this assumes text is lowest section. */
 644       lower_sect = bfd_get_section_by_name (objfile->obfd, ".text");
 645       if (lower_sect == NULL)
 646         bfd_map_over_sections (objfile->obfd, find_lowest_section,
 647                                (PTR) &lower_sect);
 648       if (lower_sect == NULL)
 649         warning ("no loadable sections found in added symbol-file %s",
 650                  objfile->name);
 651       else
 652         if ((bfd_get_section_flags (objfile->obfd, lower_sect) & SEC_CODE) == 0)
 653           warning ("Lowest section in %s is %s at %s",
 654                    objfile->name,
 655                    bfd_section_name (objfile->obfd, lower_sect),
 656                    paddr (bfd_section_vma (objfile->obfd, lower_sect)));
 657       if (lower_sect != NULL)
 658         lower_offset = bfd_section_vma (objfile->obfd, lower_sect);
 659       else
 660         lower_offset = 0;
 661
 662        /* Calculate offsets for the loadable sections.
 663          FIXME! Sections must be in order of increasing loadable section
 664          so that contiguous sections can use the lower-offset!!!
 665
 666           Adjust offsets if the segments are not contiguous.
 667           If the section is contiguous, its offset should be set to
 668          the offset of the highest loadable section lower than it
 669          (the loadable section directly below it in memory).
 670          this_offset = lower_offset = lower_addr - lower_orig_addr */
 671
 672        /* Calculate offsets for sections. */
 673       for (i=0 ; i < MAX_SECTIONS && addrs->other[i].name; i++)
 674         {
 675           if (addrs->other[i].addr != 0)
 676             {
 677               sect = bfd_get_section_by_name (objfile->obfd, addrs->other[i].name);
 678               if (sect)
 679                 {
 680                   addrs->other[i].addr -= bfd_section_vma (objfile->obfd, sect);
 681                   lower_offset = addrs->other[i].addr;
 682                   /* This is the index used by BFD. */
 683                   addrs->other[i].sectindex = sect->index ;
 684                 }
 685               else
 686                 {
 687                   warning ("section %s not found in %s", addrs->other[i].name,
 688                            objfile->name);
 689                   addrs->other[i].addr = 0;
 690                 }
 691             }
 692           else
 693             addrs->other[i].addr = lower_offset;
 694         }
 695     }
 696
 697   /* Initialize symbol reading routines for this objfile, allow complaints to
 698      appear for this new file, and record how verbose to be, then do the
 699      initial symbol reading for this file. */
 700
 701   (*objfile->sf->sym_init) (objfile);
 702   clear_complaints (1, verbo);
 703
 704   (*objfile->sf->sym_offsets) (objfile, addrs);
 705
 706 #ifndef IBM6000_TARGET
 707   /* This is a SVR4/SunOS specific hack, I think.  In any event, it
 708      screws RS/6000.  sym_offsets should be doing this sort of thing,
 709      because it knows the mapping between bfd sections and
 710      section_offsets.  */
 711   /* This is a hack.  As far as I can tell, section offsets are not
 712      target dependent.  They are all set to addr with a couple of
 713      exceptions.  The exceptions are sysvr4 shared libraries, whose
 714      offsets are kept in solib structures anyway and rs6000 xcoff
 715      which handles shared libraries in a completely unique way.
 716
 717      Section offsets are built similarly, except that they are built
 718      by adding addr in all cases because there is no clear mapping
 719      from section_offsets into actual sections.  Note that solib.c
 720      has a different algorithm for finding section offsets.
 721
 722      These should probably all be collapsed into some target
 723      independent form of shared library support.  FIXME.  */
 724
 725   if (addrs)
 726     {
 727       struct obj_section *s;
 728
 729         /* Map section offsets in "addr" back to the object's
 730            sections by comparing the section names with bfd's
 731            section names.  Then adjust the section address by
 732            the offset. */ /* for gdb/13815 */
 733
 734       ALL_OBJFILE_OSECTIONS (objfile, s)
 735         {
 736           CORE_ADDR s_addr = 0;
 737           int i;
 738
 739             for (i = 0;
 740                  !s_addr && i < MAX_SECTIONS && addrs->other[i].name;
 741                  i++)
 742               if (strcmp (s->the_bfd_section->name, addrs->other[i].name) == 0)
 743                 s_addr = addrs->other[i].addr; /* end added for gdb/13815 */
 744
 745           s->addr -= s->offset;
 746           s->addr += s_addr;
 747           s->endaddr -= s->offset;
 748           s->endaddr += s_addr;
 749           s->offset += s_addr;
 750         }
 751     }
 752 #endif /* not IBM6000_TARGET */
 753
 754   (*objfile->sf->sym_read) (objfile, mainline);
 755
 756   if (!have_partial_symbols () && !have_full_symbols ())
 757     {
 758       wrap_here ("");
 759       printf_filtered ("(no debugging symbols found)...");
 760       wrap_here ("");
 761     }
 762
 763   /* Don't allow char * to have a typename (else would get caddr_t).
 764      Ditto void *.  FIXME: Check whether this is now done by all the
 765      symbol readers themselves (many of them now do), and if so remove
 766      it from here.  */
 767
 768   TYPE_NAME (lookup_pointer_type (builtin_type_char)) = 0;
 769   TYPE_NAME (lookup_pointer_type (builtin_type_void)) = 0;
 770
 771   /* Mark the objfile has having had initial symbol read attempted.  Note
 772      that this does not mean we found any symbols... */
 773
 774   objfile->flags |= OBJF_SYMS;
 775
 776   /* Discard cleanups as symbol reading was successful.  */
 777
 778   discard_cleanups (old_chain);
 779
 780   /* Call this after reading in a new symbol table to give target
 781      dependant code a crack at the new symbols.  For instance, this
 782      could be used to update the values of target-specific symbols GDB
 783      needs to keep track of (such as _sigtramp, or whatever).  */
 784
 785   TARGET_SYMFILE_POSTREAD (objfile);
 786 }
 787
 788 /* Perform required actions after either reading in the initial
 789    symbols for a new objfile, or mapping in the symbols from a reusable
 790    objfile. */
 791
 792 void
 793 new_symfile_objfile (objfile, mainline, verbo)
 794      struct objfile *objfile;
 795      int mainline;
 796      int verbo;
 797 {
 798
 799   /* If this is the main symbol file we have to clean up all users of the
 800      old main symbol file. Otherwise it is sufficient to fixup all the
 801      breakpoints that may have been redefined by this symbol file.  */
 802   if (mainline)
 803     {
 804       /* OK, make it the "real" symbol file.  */
 805       symfile_objfile = objfile;
 806
 807       clear_symtab_users ();
 808     }
 809   else
 810     {
 811       breakpoint_re_set ();
 812     }
 813
 814   /* We're done reading the symbol file; finish off complaints.  */
 815   clear_complaints (0, verbo);
 816 }
 817
 818 /* Process a symbol file, as either the main file or as a dynamically
 819    loaded file.
 820
 821    NAME is the file name (which will be tilde-expanded and made
 822    absolute herein) (but we don't free or modify NAME itself).
 823    FROM_TTY says how verbose to be.  MAINLINE specifies whether this
 824    is the main symbol file, or whether it's an extra symbol file such
 825    as dynamically loaded code.  If !mainline, ADDR is the address
 826    where the text segment was loaded.
 827
 828    Upon success, returns a pointer to the objfile that was added.
 829    Upon failure, jumps back to command level (never returns). */
 830
 831 struct objfile *
 832 symbol_file_add (name, from_tty, addrs, mainline, flags)
 833      char *name;
 834      int from_tty;
 835      struct section_addr_info *addrs;
 836      int mainline;
 837      int flags;
 838 {
 839   struct objfile *objfile;
 840   struct partial_symtab *psymtab;
 841   bfd *abfd;
 842
 843   /* Open a bfd for the file, and give user a chance to burp if we'd be
 844      interactively wiping out any existing symbols.  */
 845
 846   abfd = symfile_bfd_open (name);
 847
 848   if ((have_full_symbols () || have_partial_symbols ())
 849       && mainline
 850       && from_tty
 851       && !query ("Load new symbol table from \"%s\"? ", name))
 852     error ("Not confirmed.");
 853
 854   objfile = allocate_objfile (abfd, flags);
 855
 856   /* If the objfile uses a mapped symbol file, and we have a psymtab for
 857      it, then skip reading any symbols at this time. */
 858
 859   if ((objfile->flags & OBJF_MAPPED) && (objfile->flags & OBJF_SYMS))
 860     {
 861       /* We mapped in an existing symbol table file that already has had
 862          initial symbol reading performed, so we can skip that part.  Notify
 863          the user that instead of reading the symbols, they have been mapped.
 864        */
 865       if (from_tty || info_verbose)
 866         {
 867           printf_filtered ("Mapped symbols for %s...", name);
 868           wrap_here ("");
 869           gdb_flush (gdb_stdout);
 870         }
 871       init_entry_point_info (objfile);
 872       find_sym_fns (objfile);
 873     }
 874   else
 875     {
 876       /* We either created a new mapped symbol table, mapped an existing
 877          symbol table file which has not had initial symbol reading
 878          performed, or need to read an unmapped symbol table. */
 879       if (from_tty || info_verbose)
 880         {
 881           if (pre_add_symbol_hook)
 882             pre_add_symbol_hook (name);
 883           else
 884             {
 885               printf_filtered ("Reading symbols from %s...", name);
 886               wrap_here ("");
 887               gdb_flush (gdb_stdout);
 888             }
 889         }
 890       syms_from_objfile (objfile, addrs, mainline, from_tty);
 891     }
 892
 893   /* We now have at least a partial symbol table.  Check to see if the
 894      user requested that all symbols be read on initial access via either
 895      the gdb startup command line or on a per symbol file basis.  Expand
 896      all partial symbol tables for this objfile if so. */
 897
 898   if ((flags & OBJF_READNOW) || readnow_symbol_files)
 899     {
 900       if (from_tty || info_verbose)
 901         {
 902           printf_filtered ("expanding to full symbols...");
 903           wrap_here ("");
 904           gdb_flush (gdb_stdout);
 905         }
 906
 907       for (psymtab = objfile->psymtabs;
 908            psymtab != NULL;
 909            psymtab = psymtab->next)
 910         {
 911           psymtab_to_symtab (psymtab);
 912         }
 913     }
 914
 915   if (from_tty || info_verbose)
 916     {
 917       if (post_add_symbol_hook)
 918         post_add_symbol_hook ();
 919       else
 920         {
 921           printf_filtered ("done.\n");
 922           gdb_flush (gdb_stdout);
 923         }
 924     }
 925
 926   new_symfile_objfile (objfile, mainline, from_tty);
 927
 928   if (target_new_objfile_hook)
 929     target_new_objfile_hook (objfile);
 930
 931   return (objfile);
 932 }
 933
 934 /* This is the symbol-file command.  Read the file, analyze its
 935    symbols, and add a struct symtab to a symtab list.  The syntax of
 936    the command is rather bizarre--(1) buildargv implements various
 937    quoting conventions which are undocumented and have little or
 938    nothing in common with the way things are quoted (or not quoted)
 939    elsewhere in GDB, (2) options are used, which are not generally
 940    used in GDB (perhaps "set mapped on", "set readnow on" would be
 941    better), (3) the order of options matters, which is contrary to GNU
 942    conventions (because it is confusing and inconvenient).  */
 943 /* Note: ezannoni 2000-04-17. This function used to have support for
 944    rombug (see remote-os9k.c). It consisted of a call to target_link()
 945    (target.c) to get the address of the text segment from the target,
 946    and pass that to symbol_file_add(). This is no longer supported. */
 947
 948 void
 949 symbol_file_command (args, from_tty)
 950      char *args;
 951      int from_tty;
 952 {
 953   char **argv;
 954   char *name = NULL;
 955   struct cleanup *cleanups;
 956   int flags = OBJF_USERLOADED;
 957
 958   dont_repeat ();
 959
 960   if (args == NULL)
 961     {
 962       if ((have_full_symbols () || have_partial_symbols ())
 963           && from_tty
 964           && !query ("Discard symbol table from `%s'? ",
 965                      symfile_objfile->name))
 966         error ("Not confirmed.");
 967       free_all_objfiles ();
 968
 969       /* solib descriptors may have handles to objfiles.  Since their
 970          storage has just been released, we'd better wipe the solib
 971          descriptors as well.
 972        */
 973 #if defined(SOLIB_RESTART)
 974       SOLIB_RESTART ();
 975 #endif
 976
 977       symfile_objfile = NULL;
 978       if (from_tty)
 979           printf_unfiltered ("No symbol file now.\n");
 980 #ifdef HPUXHPPA
 981       RESET_HP_UX_GLOBALS ();
 982 #endif
 983     }
 984   else
 985     {
 986       if ((argv = buildargv (args)) == NULL)
 987         {
 988           nomem (0);
 989         }
 990       cleanups = make_cleanup_freeargv (argv);
 991       while (*argv != NULL)
 992         {
 993           if (STREQ (*argv, "-mapped"))
 994             flags |= OBJF_MAPPED;
 995           else
 996             if (STREQ (*argv, "-readnow"))
 997               flags |= OBJF_READNOW;
 998             else
 999               if (**argv == '-')
1000                 error ("unknown option `%s'", *argv);
1001               else
1002                 {
1003                   name = *argv;
1004                   symbol_file_add (name, from_tty, NULL, 1, flags);
1005 #ifdef HPUXHPPA
1006                   RESET_HP_UX_GLOBALS ();
1007 #endif
1008                   /* Getting new symbols may change our opinion about
1009                      what is frameless.  */
1010                   reinit_frame_cache ();
1011
1012                   set_initial_language ();
1013                 }
1014           argv++;
1015         }
1016
1017       if (name == NULL)
1018         {
1019           error ("no symbol file name was specified");
1020         }
1021       TUIDO (((TuiOpaqueFuncPtr) tuiDisplayMainFunction));
1022       do_cleanups (cleanups);
1023     }
1024 }
1025
1026 /* Set the initial language.
1027
1028    A better solution would be to record the language in the psymtab when reading
1029    partial symbols, and then use it (if known) to set the language.  This would
1030    be a win for formats that encode the language in an easily discoverable place,
1031    such as DWARF.  For stabs, we can jump through hoops looking for specially
1032    named symbols or try to intuit the language from the specific type of stabs
1033    we find, but we can't do that until later when we read in full symbols.
1034    FIXME.  */
1035
1036 static void
1037 set_initial_language ()
1038 {
1039   struct partial_symtab *pst;
1040   enum language lang = language_unknown;
1041
1042   pst = find_main_psymtab ();
1043   if (pst != NULL)
1044     {
1045       if (pst->filename != NULL)
1046         {
1047           lang = deduce_language_from_filename (pst->filename);
1048         }
1049       if (lang == language_unknown)
1050         {
1051           /* Make C the default language */
1052           lang = language_c;
1053         }
1054       set_language (lang);
1055       expected_language = current_language;     /* Don't warn the user */
1056     }
1057 }
1058
1059 /* Open file specified by NAME and hand it off to BFD for preliminary
1060    analysis.  Result is a newly initialized bfd *, which includes a newly
1061    malloc'd` copy of NAME (tilde-expanded and made absolute).
1062    In case of trouble, error() is called.  */
1063
1064 bfd *
1065 symfile_bfd_open (name)
1066      char *name;
1067 {
1068   bfd *sym_bfd;
1069   int desc;
1070   char *absolute_name;
1071
1072
1073
1074   name = tilde_expand (name);   /* Returns 1st new malloc'd copy */
1075
1076   /* Look down path for it, allocate 2nd new malloc'd copy.  */
1077   desc = openp (getenv ("PATH"), 1, name, O_RDONLY | O_BINARY, 0, &absolute_name);
1078 #if defined(__GO32__) || defined(_WIN32)
1079   if (desc < 0)
1080     {
1081       char *exename = alloca (strlen (name) + 5);
1082       strcat (strcpy (exename, name), ".exe");
1083       desc = openp (getenv ("PATH"), 1, exename, O_RDONLY | O_BINARY,
1084                     0, &absolute_name);
1085     }
1086 #endif
1087   if (desc < 0)
1088     {
1089       make_cleanup (free, name);
1090       perror_with_name (name);
1091     }
1092   free (name);                  /* Free 1st new malloc'd copy */
1093   name = absolute_name;         /* Keep 2nd malloc'd copy in bfd */
1094   /* It'll be freed in free_objfile(). */
1095
1096   sym_bfd = bfd_fdopenr (name, gnutarget, desc);
1097   if (!sym_bfd)
1098     {
1099       close (desc);
1100       make_cleanup (free, name);
1101       error ("\"%s\": can't open to read symbols: %s.", name,
1102              bfd_errmsg (bfd_get_error ()));
1103     }
1104   sym_bfd->cacheable = true;
1105
1106   if (!bfd_check_format (sym_bfd, bfd_object))
1107     {
1108       /* FIXME: should be checking for errors from bfd_close (for one thing,
1109          on error it does not free all the storage associated with the
1110          bfd).  */
1111       bfd_close (sym_bfd);      /* This also closes desc */
1112       make_cleanup (free, name);
1113       error ("\"%s\": can't read symbols: %s.", name,
1114              bfd_errmsg (bfd_get_error ()));
1115     }
1116   return (sym_bfd);
1117 }
1118
1119 /* Link a new symtab_fns into the global symtab_fns list.  Called on gdb
1120    startup by the _initialize routine in each object file format reader,
1121    to register information about each format the the reader is prepared
1122    to handle. */
1123
1124 void
1125 add_symtab_fns (sf)
1126      struct sym_fns *sf;
1127 {
1128   sf->next = symtab_fns;
1129   symtab_fns = sf;
1130 }
1131
1132
1133 /* Initialize to read symbols from the symbol file sym_bfd.  It either
1134    returns or calls error().  The result is an initialized struct sym_fns
1135    in the objfile structure, that contains cached information about the
1136    symbol file.  */
1137
1138 static void
1139 find_sym_fns (objfile)
1140      struct objfile *objfile;
1141 {
1142   struct sym_fns *sf;
1143   enum bfd_flavour our_flavour = bfd_get_flavour (objfile->obfd);
1144   char *our_target = bfd_get_target (objfile->obfd);
1145
1146   /* Special kludge for RS/6000 and PowerMac.  See xcoffread.c.  */
1147   if (STREQ (our_target, "aixcoff-rs6000") ||
1148       STREQ (our_target, "xcoff-powermac"))
1149     our_flavour = (enum bfd_flavour) -1;
1150
1151   /* Special kludge for apollo.  See dstread.c.  */
1152   if (STREQN (our_target, "apollo", 6))
1153     our_flavour = (enum bfd_flavour) -2;
1154
1155   for (sf = symtab_fns; sf != NULL; sf = sf->next)
1156     {
1157       if (our_flavour == sf->sym_flavour)
1158         {
1159           objfile->sf = sf;
1160           return;
1161         }
1162     }
1163   error ("I'm sorry, Dave, I can't do that.  Symbol format `%s' unknown.",
1164          bfd_get_target (objfile->obfd));
1165 }
1166 \f
1167 /* This function runs the load command of our current target.  */
1168
1169 static void
1170 load_command (arg, from_tty)
1171      char *arg;
1172      int from_tty;
1173 {
1174   if (arg == NULL)
1175     arg = get_exec_file (1);
1176   target_load (arg, from_tty);
1177 }
1178
1179 /* This version of "load" should be usable for any target.  Currently
1180    it is just used for remote targets, not inftarg.c or core files,
1181    on the theory that only in that case is it useful.
1182
1183    Avoiding xmodem and the like seems like a win (a) because we don't have
1184    to worry about finding it, and (b) On VMS, fork() is very slow and so
1185    we don't want to run a subprocess.  On the other hand, I'm not sure how
1186    performance compares.  */
1187
1188 static int download_write_size = 512;
1189 static int validate_download = 0;
1190
1191 void
1192 generic_load (char *args, int from_tty)
1193 {
1194   asection *s;
1195   bfd *loadfile_bfd;
1196   time_t start_time, end_time;  /* Start and end times of download */
1197   unsigned long data_count = 0; /* Number of bytes transferred to memory */
1198   unsigned long write_count = 0;        /* Number of writes needed. */
1199   unsigned long load_offset;    /* offset to add to vma for each section */
1200   char *filename;
1201   struct cleanup *old_cleanups;
1202   char *offptr;
1203   CORE_ADDR total_size = 0;
1204   CORE_ADDR total_sent = 0;
1205
1206   /* Parse the input argument - the user can specify a load offset as
1207      a second argument. */
1208   filename = xmalloc (strlen (args) + 1);
1209   old_cleanups = make_cleanup (free, filename);
1210   strcpy (filename, args);
1211   offptr = strchr (filename, ' ');
1212   if (offptr != NULL)
1213     {
1214       char *endptr;
1215       load_offset = strtoul (offptr, &endptr, 0);
1216       if (offptr == endptr)
1217         error ("Invalid download offset:%s\n", offptr);
1218       *offptr = '\0';
1219     }
1220   else
1221     load_offset = 0;
1222
1223   /* Open the file for loading. */
1224   loadfile_bfd = bfd_openr (filename, gnutarget);
1225   if (loadfile_bfd == NULL)
1226     {
1227       perror_with_name (filename);
1228       return;
1229     }
1230
1231   /* FIXME: should be checking for errors from bfd_close (for one thing,
1232      on error it does not free all the storage associated with the
1233      bfd).  */
1234   make_cleanup_bfd_close (loadfile_bfd);
1235
1236   if (!bfd_check_format (loadfile_bfd, bfd_object))
1237     {
1238       error ("\"%s\" is not an object file: %s", filename,
1239              bfd_errmsg (bfd_get_error ()));
1240     }
1241
1242   for (s = loadfile_bfd->sections; s; s = s->next)
1243     if (s->flags & SEC_LOAD)
1244       total_size += bfd_get_section_size_before_reloc (s);
1245
1246   start_time = time (NULL);
1247
1248   for (s = loadfile_bfd->sections; s; s = s->next)
1249     {
1250       if (s->flags & SEC_LOAD)
1251         {
1252           CORE_ADDR size = bfd_get_section_size_before_reloc (s);
1253           if (size > 0)
1254             {
1255               char *buffer;
1256               struct cleanup *old_chain;
1257               CORE_ADDR lma = s->lma + load_offset;
1258               CORE_ADDR block_size;
1259               int err;
1260               const char *sect_name = bfd_get_section_name (loadfile_bfd, s);
1261               CORE_ADDR sent;
1262
1263               if (download_write_size > 0 && size > download_write_size)
1264                 block_size = download_write_size;
1265               else
1266                 block_size = size;
1267
1268               buffer = xmalloc (size);
1269               old_chain = make_cleanup (free, buffer);
1270
1271               /* Is this really necessary?  I guess it gives the user something
1272                  to look at during a long download.  */
1273 #ifdef UI_OUT
1274               ui_out_message (uiout, 0, "Loading section %s, size 0x%s lma 0x%s\n",
1275                            sect_name, paddr_nz (size), paddr_nz (lma));
1276 #else
1277               fprintf_unfiltered (gdb_stdout,
1278                                   "Loading section %s, size 0x%s lma 0x%s\n",
1279                                   sect_name, paddr_nz (size), paddr_nz (lma));
1280 #endif
1281
1282               bfd_get_section_contents (loadfile_bfd, s, buffer, 0, size);
1283
1284               sent = 0;
1285               do
1286                 {
1287                   CORE_ADDR len;
1288                   CORE_ADDR this_transfer = size - sent;
1289                   if (this_transfer >= block_size)
1290                     this_transfer = block_size;
1291                   len = target_write_memory_partial (lma, buffer,
1292                                                      this_transfer, &err);
1293                   if (err)
1294                     break;
1295                   if (validate_download)
1296                     {
1297                       /* Broken memories and broken monitors manifest
1298                          themselves here when bring new computers to
1299                          life.  This doubles already slow downloads.  */
1300                       /* NOTE: cagney/1999-10-18: A more efficient
1301                          implementation might add a verify_memory()
1302                          method to the target vector and then use
1303                          that.  remote.c could implement that method
1304                          using the ``qCRC'' packet.  */
1305                       char *check = xmalloc (len);
1306                       struct cleanup *verify_cleanups = make_cleanup (free, check);
1307                       if (target_read_memory (lma, check, len) != 0)
1308                         error ("Download verify read failed at 0x%s",
1309                                paddr (lma));
1310                       if (memcmp (buffer, check, len) != 0)
1311                         error ("Download verify compare failed at 0x%s",
1312                                paddr (lma));
1313                       do_cleanups (verify_cleanups);
1314                     }
1315                   data_count += len;
1316                   lma += len;
1317                   buffer += len;
1318                   write_count += 1;
1319                   sent += len;
1320                   total_sent += len;
1321                   if (quit_flag
1322                       || (ui_load_progress_hook != NULL
1323                           && ui_load_progress_hook (sect_name, sent)))
1324                     error ("Canceled the download");
1325
1326                   if (show_load_progress != NULL)
1327                     show_load_progress (sect_name, sent, size, total_sent, total_size);
1328                 }
1329               while (sent < size);
1330
1331               if (err != 0)
1332                 error ("Memory access error while loading section %s.", sect_name);
1333
1334               do_cleanups (old_chain);
1335             }
1336         }
1337     }
1338
1339   end_time = time (NULL);
1340   {
1341     CORE_ADDR entry;
1342     entry = bfd_get_start_address (loadfile_bfd);
1343 #ifdef UI_OUT
1344    ui_out_text (uiout, "Start address ");
1345    ui_out_field_fmt (uiout, "address", "0x%s" , paddr_nz (entry));
1346    ui_out_text (uiout, ", load size ");
1347    ui_out_field_fmt (uiout, "load-size", "%ld" , data_count);
1348    ui_out_text (uiout, "\n");
1349
1350 #else
1351     fprintf_unfiltered (gdb_stdout,
1352                         "Start address 0x%s , load size %ld\n",
1353                         paddr_nz (entry), data_count);
1354 #endif
1355     /* We were doing this in remote-mips.c, I suspect it is right
1356        for other targets too.  */
1357     write_pc (entry);
1358   }
1359
1360   /* FIXME: are we supposed to call symbol_file_add or not?  According to
1361      a comment from remote-mips.c (where a call to symbol_file_add was
1362      commented out), making the call confuses GDB if more than one file is
1363      loaded in.  remote-nindy.c had no call to symbol_file_add, but remote-vx.c
1364      does.  */
1365
1366   print_transfer_performance (gdb_stdout, data_count, write_count,
1367                               end_time - start_time);
1368
1369   do_cleanups (old_cleanups);
1370 }
1371
1372 /* Report how fast the transfer went. */
1373
1374 /* DEPRECATED: cagney/1999-10-18: report_transfer_performance is being
1375    replaced by print_transfer_performance (with a very different
1376    function signature). */
1377
1378 void
1379 report_transfer_performance (data_count, start_time, end_time)
1380      unsigned long data_count;
1381      time_t start_time, end_time;
1382 {
1383   print_transfer_performance (gdb_stdout, data_count, end_time - start_time, 0);
1384 }
1385
1386 void
1387 print_transfer_performance (struct ui_file *stream,
1388                             unsigned long data_count,
1389                             unsigned long write_count,
1390                             unsigned long time_count)
1391 {
1392 #ifdef UI_OUT
1393   ui_out_text (uiout, "Transfer rate: ");
1394   if (time_count > 0)
1395     {
1396       ui_out_field_fmt (uiout, "transfer-rate", "%ld",
1397                         (data_count * 8) / time_count);
1398       ui_out_text (uiout, " bits/sec");
1399     }
1400   else
1401     {
1402       ui_out_field_fmt (uiout, "transferred-bits", "%ld", (data_count * 8));
1403       ui_out_text (uiout, " bits in <1 sec");
1404     }
1405   if (write_count > 0)
1406     {
1407       ui_out_text (uiout, ", ");
1408       ui_out_field_fmt (uiout, "write-rate", "%ld", data_count / write_count);
1409       ui_out_text (uiout, " bytes/write");
1410     }
1411   ui_out_text (uiout, ".\n");
1412 #else
1413   fprintf_unfiltered (stream, "Transfer rate: ");
1414   if (time_count > 0)
1415     fprintf_unfiltered (stream, "%ld bits/sec", (data_count * 8) / time_count);
1416   else
1417     fprintf_unfiltered (stream, "%ld bits in <1 sec", (data_count * 8));
1418   if (write_count > 0)
1419     fprintf_unfiltered (stream, ", %ld bytes/write", data_count / write_count);
1420   fprintf_unfiltered (stream, ".\n");
1421 #endif
1422 }
1423
1424 /* This function allows the addition of incrementally linked object files.
1425    It does not modify any state in the target, only in the debugger.  */
1426 /* Note: ezannoni 2000-04-13 This function/command used to have a
1427    special case syntax for the rombug target (Rombug is the boot
1428    monitor for Microware's OS-9 / OS-9000, see remote-os9k.c). In the
1429    rombug case, the user doesn't need to supply a text address,
1430    instead a call to target_link() (in target.c) would supply the
1431    value to use. We are now discontinuing this type of ad hoc syntax. */
1432
1433 /* ARGSUSED */
1434 static void
1435 add_symbol_file_command (args, from_tty)
1436      char *args;
1437      int from_tty;
1438 {
1439   char *filename = NULL;
1440   int flags = OBJF_USERLOADED;
1441   char *arg;
1442   int expecting_option = 0;
1443   int section_index = 0;
1444   int argcnt = 0;
1445   int sec_num = 0;
1446   int i;
1447   int expecting_sec_name = 0;
1448   int expecting_sec_addr = 0;
1449
1450   struct
1451   {
1452     char *name;
1453     char *value;
1454   } sect_opts[SECT_OFF_MAX];
1455
1456   struct section_addr_info section_addrs;
1457   struct cleanup *my_cleanups;
1458
1459   dont_repeat ();
1460
1461   if (args == NULL)
1462     error ("add-symbol-file takes a file name and an address");
1463
1464   /* Make a copy of the string that we can safely write into. */
1465   args = xstrdup (args);
1466
1467   /* Ensure section_addrs is initialized */
1468   memset (&section_addrs, 0, sizeof (section_addrs));
1469
1470   while (*args != '\000')
1471     {
1472       /* Any leading spaces? */
1473       while (isspace (*args))
1474         args++;
1475
1476       /* Point arg to the beginning of the argument. */
1477       arg = args;
1478
1479       /* Move args pointer over the argument. */
1480       while ((*args != '\000') && !isspace (*args))
1481         args++;
1482
1483       /* If there are more arguments, terminate arg and
1484          proceed past it. */
1485       if (*args != '\000')
1486         *args++ = '\000';
1487
1488       /* Now process the argument. */
1489       if (argcnt == 0)
1490         {
1491           /* The first argument is the file name. */
1492           filename = tilde_expand (arg);
1493           my_cleanups = make_cleanup (free, filename);
1494         }
1495       else
1496         if (argcnt == 1)
1497           {
1498             /* The second argument is always the text address at which
1499                to load the program. */
1500             sect_opts[section_index].name = ".text";
1501             sect_opts[section_index].value = arg;
1502             section_index++;
1503           }
1504         else
1505           {
1506             /* It's an option (starting with '-') or it's an argument
1507                to an option */
1508
1509             if (*arg == '-')
1510               {
1511                 if (strcmp (arg, "-mapped") == 0)
1512                   flags |= OBJF_MAPPED;
1513                 else
1514                   if (strcmp (arg, "-readnow") == 0)
1515                     flags |= OBJF_READNOW;
1516                   else
1517                     if (strcmp (arg, "-s") == 0)
1518                       {
1519                         if (section_index >= SECT_OFF_MAX)
1520                           error ("Too many sections specified.");
1521                         expecting_sec_name = 1;
1522                         expecting_sec_addr = 1;
1523                       }
1524               }
1525             else
1526               {
1527                 if (expecting_sec_name)
1528                   {
1529                     sect_opts[section_index].name = arg;
1530                     expecting_sec_name = 0;
1531                   }
1532                 else
1533                   if (expecting_sec_addr)
1534                     {
1535                       sect_opts[section_index].value = arg;
1536                       expecting_sec_addr = 0;
1537                       section_index++;
1538                     }
1539                   else
1540                     error ("USAGE: add-symbol-file <filename> <textaddress> [-mapped] [-readnow] [-s <secname> <addr>]*");
1541               }
1542           }
1543       argcnt++;
1544     }
1545
1546   /* Print the prompt for the query below. And save the arguments into
1547      a sect_addr_info structure to be passed around to other
1548      functions.  We have to split this up into separate print
1549      statements because local_hex_string returns a local static
1550      string. */
1551
1552   printf_filtered ("add symbol table from file \"%s\" at\n", filename);
1553   for (i = 0; i < section_index; i++)
1554     {
1555       CORE_ADDR addr;
1556       char *val = sect_opts[i].value;
1557       char *sec = sect_opts[i].name;
1558
1559       val = sect_opts[i].value;
1560       if (val[0] == '0' && val[1] == 'x')
1561         addr = strtoul (val+2, NULL, 16);
1562       else
1563         addr = strtoul (val, NULL, 10);
1564
1565       /* Here we store the section offsets in the order they were
1566          entered on the command line. */
1567       section_addrs.other[sec_num].name = sec;
1568       section_addrs.other[sec_num].addr = addr;
1569       printf_filtered ("\t%s_addr = %s\n",
1570                        sec,
1571                        local_hex_string ((unsigned long)addr));
1572       sec_num++;
1573
1574       /* The object's sections are initialized when a
1575          call is made to build_objfile_section_table (objfile).
1576          This happens in reread_symbols.
1577          At this point, we don't know what file type this is,
1578          so we can't determine what section names are valid.  */
1579     }
1580
1581   if (from_tty && (!query ("%s", "")))
1582     error ("Not confirmed.");
1583
1584   symbol_file_add (filename, from_tty, &section_addrs, 0, flags);
1585
1586   /* Getting new symbols may change our opinion about what is
1587      frameless.  */
1588   reinit_frame_cache ();
1589   do_cleanups (my_cleanups);
1590 }
1591 \f
1592 static void
1593 add_shared_symbol_files_command (args, from_tty)
1594      char *args;
1595      int from_tty;
1596 {
1597 #ifdef ADD_SHARED_SYMBOL_FILES
1598   ADD_SHARED_SYMBOL_FILES (args, from_tty);
1599 #else
1600   error ("This command is not available in this configuration of GDB.");
1601 #endif
1602 }
1603 \f
1604 /* Re-read symbols if a symbol-file has changed.  */
1605 void
1606 reread_symbols ()
1607 {
1608   struct objfile *objfile;
1609   long new_modtime;
1610   int reread_one = 0;
1611   struct stat new_statbuf;
1612   int res;
1613
1614   /* With the addition of shared libraries, this should be modified,
1615      the load time should be saved in the partial symbol tables, since
1616      different tables may come from different source files.  FIXME.
1617      This routine should then walk down each partial symbol table
1618      and see if the symbol table that it originates from has been changed */
1619
1620   for (objfile = object_files; objfile; objfile = objfile->next)
1621     {
1622       if (objfile->obfd)
1623         {
1624 #ifdef IBM6000_TARGET
1625           /* If this object is from a shared library, then you should
1626              stat on the library name, not member name. */
1627
1628           if (objfile->obfd->my_archive)
1629             res = stat (objfile->obfd->my_archive->filename, &new_statbuf);
1630           else
1631 #endif
1632             res = stat (objfile->name, &new_statbuf);
1633           if (res != 0)
1634             {
1635               /* FIXME, should use print_sys_errmsg but it's not filtered. */
1636               printf_filtered ("`%s' has disappeared; keeping its symbols.\n",
1637                                objfile->name);
1638               continue;
1639             }
1640           new_modtime = new_statbuf.st_mtime;
1641           if (new_modtime != objfile->mtime)
1642             {
1643               struct cleanup *old_cleanups;
1644               struct section_offsets *offsets;
1645               int num_offsets;
1646               char *obfd_filename;
1647
1648               printf_filtered ("`%s' has changed; re-reading symbols.\n",
1649                                objfile->name);
1650
1651               /* There are various functions like symbol_file_add,
1652                  symfile_bfd_open, syms_from_objfile, etc., which might
1653                  appear to do what we want.  But they have various other
1654                  effects which we *don't* want.  So we just do stuff
1655                  ourselves.  We don't worry about mapped files (for one thing,
1656                  any mapped file will be out of date).  */
1657
1658               /* If we get an error, blow away this objfile (not sure if
1659                  that is the correct response for things like shared
1660                  libraries).  */
1661               old_cleanups = make_cleanup_free_objfile (objfile);
1662               /* We need to do this whenever any symbols go away.  */
1663               make_cleanup (clear_symtab_users_cleanup, 0 /*ignore*/);
1664
1665               /* Clean up any state BFD has sitting around.  We don't need
1666                  to close the descriptor but BFD lacks a way of closing the
1667                  BFD without closing the descriptor.  */
1668               obfd_filename = bfd_get_filename (objfile->obfd);
1669               if (!bfd_close (objfile->obfd))
1670                 error ("Can't close BFD for %s: %s", objfile->name,
1671                        bfd_errmsg (bfd_get_error ()));
1672               objfile->obfd = bfd_openr (obfd_filename, gnutarget);
1673               if (objfile->obfd == NULL)
1674                 error ("Can't open %s to read symbols.", objfile->name);
1675               /* bfd_openr sets cacheable to true, which is what we want.  */
1676               if (!bfd_check_format (objfile->obfd, bfd_object))
1677                 error ("Can't read symbols from %s: %s.", objfile->name,
1678                        bfd_errmsg (bfd_get_error ()));
1679
1680               /* Save the offsets, we will nuke them with the rest of the
1681                  psymbol_obstack.  */
1682               num_offsets = objfile->num_sections;
1683               offsets = (struct section_offsets *) alloca (SIZEOF_SECTION_OFFSETS);
1684               memcpy (offsets, objfile->section_offsets, SIZEOF_SECTION_OFFSETS);
1685
1686               /* Nuke all the state that we will re-read.  Much of the following
1687                  code which sets things to NULL really is necessary to tell
1688                  other parts of GDB that there is nothing currently there.  */
1689
1690               /* FIXME: Do we have to free a whole linked list, or is this
1691                  enough?  */
1692               if (objfile->global_psymbols.list)
1693                 mfree (objfile->md, objfile->global_psymbols.list);
1694               memset (&objfile->global_psymbols, 0,
1695                       sizeof (objfile->global_psymbols));
1696               if (objfile->static_psymbols.list)
1697                 mfree (objfile->md, objfile->static_psymbols.list);
1698               memset (&objfile->static_psymbols, 0,
1699                       sizeof (objfile->static_psymbols));
1700
1701               /* Free the obstacks for non-reusable objfiles */
1702               free_bcache (&objfile->psymbol_cache);
1703               obstack_free (&objfile->psymbol_obstack, 0);
1704               obstack_free (&objfile->symbol_obstack, 0);
1705               obstack_free (&objfile->type_obstack, 0);
1706               objfile->sections = NULL;
1707               objfile->symtabs = NULL;
1708               objfile->psymtabs = NULL;
1709               objfile->free_psymtabs = NULL;
1710               objfile->msymbols = NULL;
1711               objfile->minimal_symbol_count = 0;
1712               memset (&objfile->msymbol_hash, 0,
1713                       sizeof (objfile->msymbol_hash));
1714               memset (&objfile->msymbol_demangled_hash, 0,
1715                       sizeof (objfile->msymbol_demangled_hash));
1716               objfile->fundamental_types = NULL;
1717               if (objfile->sf != NULL)
1718                 {
1719                   (*objfile->sf->sym_finish) (objfile);
1720                 }
1721
1722               /* We never make this a mapped file.  */
1723               objfile->md = NULL;
1724               /* obstack_specify_allocation also initializes the obstack so
1725                  it is empty.  */
1726               obstack_specify_allocation (&objfile->psymbol_cache.cache, 0, 0,
1727                                           xmalloc, free);
1728               obstack_specify_allocation (&objfile->psymbol_obstack, 0, 0,
1729                                           xmalloc, free);
1730               obstack_specify_allocation (&objfile->symbol_obstack, 0, 0,
1731                                           xmalloc, free);
1732               obstack_specify_allocation (&objfile->type_obstack, 0, 0,
1733                                           xmalloc, free);
1734               if (build_objfile_section_table (objfile))
1735                 {
1736                   error ("Can't find the file sections in `%s': %s",
1737                          objfile->name, bfd_errmsg (bfd_get_error ()));
1738                 }
1739
1740               /* We use the same section offsets as from last time.  I'm not
1741                  sure whether that is always correct for shared libraries.  */
1742               objfile->section_offsets = (struct section_offsets *)
1743                 obstack_alloc (&objfile->psymbol_obstack, SIZEOF_SECTION_OFFSETS);
1744               memcpy (objfile->section_offsets, offsets, SIZEOF_SECTION_OFFSETS);
1745               objfile->num_sections = num_offsets;
1746
1747               /* What the hell is sym_new_init for, anyway?  The concept of
1748                  distinguishing between the main file and additional files
1749                  in this way seems rather dubious.  */
1750               if (objfile == symfile_objfile)
1751                 {
1752                   (*objfile->sf->sym_new_init) (objfile);
1753 #ifdef HPUXHPPA
1754                   RESET_HP_UX_GLOBALS ();
1755 #endif
1756                 }
1757
1758               (*objfile->sf->sym_init) (objfile);
1759               clear_complaints (1, 1);
1760               /* The "mainline" parameter is a hideous hack; I think leaving it
1761                  zero is OK since dbxread.c also does what it needs to do if
1762                  objfile->global_psymbols.size is 0.  */
1763               (*objfile->sf->sym_read) (objfile, 0);
1764               if (!have_partial_symbols () && !have_full_symbols ())
1765                 {
1766                   wrap_here ("");
1767                   printf_filtered ("(no debugging symbols found)\n");
1768                   wrap_here ("");
1769                 }
1770               objfile->flags |= OBJF_SYMS;
1771
1772               /* We're done reading the symbol file; finish off complaints.  */
1773               clear_complaints (0, 1);
1774
1775               /* Getting new symbols may change our opinion about what is
1776                  frameless.  */
1777
1778               reinit_frame_cache ();
1779
1780               /* Discard cleanups as symbol reading was successful.  */
1781               discard_cleanups (old_cleanups);
1782
1783               /* If the mtime has changed between the time we set new_modtime
1784                  and now, we *want* this to be out of date, so don't call stat
1785                  again now.  */
1786               objfile->mtime = new_modtime;
1787               reread_one = 1;
1788
1789               /* Call this after reading in a new symbol table to give target
1790                  dependant code a crack at the new symbols.  For instance, this
1791                  could be used to update the values of target-specific symbols GDB
1792                  needs to keep track of (such as _sigtramp, or whatever).  */
1793
1794               TARGET_SYMFILE_POSTREAD (objfile);
1795             }
1796         }
1797     }
1798
1799   if (reread_one)
1800     clear_symtab_users ();
1801 }
1802 \f
1803
1804
1805 typedef struct
1806 {
1807   char *ext;
1808   enum language lang;
1809 }
1810 filename_language;
1811
1812 static filename_language *filename_language_table;
1813 static int fl_table_size, fl_table_next;
1814
1815 static void
1816 add_filename_language (ext, lang)
1817      char *ext;
1818      enum language lang;
1819 {
1820   if (fl_table_next >= fl_table_size)
1821     {
1822       fl_table_size += 10;
1823       filename_language_table = realloc (filename_language_table,
1824                                          fl_table_size);
1825     }
1826
1827   filename_language_table[fl_table_next].ext = strsave (ext);
1828   filename_language_table[fl_table_next].lang = lang;
1829   fl_table_next++;
1830 }
1831
1832 static char *ext_args;
1833
1834 static void
1835 set_ext_lang_command (args, from_tty)
1836      char *args;
1837      int from_tty;
1838 {
1839   int i;
1840   char *cp = ext_args;
1841   enum language lang;
1842
1843   /* First arg is filename extension, starting with '.' */
1844   if (*cp != '.')
1845     error ("'%s': Filename extension must begin with '.'", ext_args);
1846
1847   /* Find end of first arg.  */
1848   while (*cp && !isspace (*cp))
1849     cp++;
1850
1851   if (*cp == '\0')
1852     error ("'%s': two arguments required -- filename extension and language",
1853            ext_args);
1854
1855   /* Null-terminate first arg */
1856   *cp++ = '\0';
1857
1858   /* Find beginning of second arg, which should be a source language.  */
1859   while (*cp && isspace (*cp))
1860     cp++;
1861
1862   if (*cp == '\0')
1863     error ("'%s': two arguments required -- filename extension and language",
1864            ext_args);
1865
1866   /* Lookup the language from among those we know.  */
1867   lang = language_enum (cp);
1868
1869   /* Now lookup the filename extension: do we already know it?  */
1870   for (i = 0; i < fl_table_next; i++)
1871     if (0 == strcmp (ext_args, filename_language_table[i].ext))
1872       break;
1873
1874   if (i >= fl_table_next)
1875     {
1876       /* new file extension */
1877       add_filename_language (ext_args, lang);
1878     }
1879   else
1880     {
1881       /* redefining a previously known filename extension */
1882
1883       /* if (from_tty) */
1884       /*   query ("Really make files of type %s '%s'?", */
1885       /*          ext_args, language_str (lang));           */
1886
1887       free (filename_language_table[i].ext);
1888       filename_language_table[i].ext = strsave (ext_args);
1889       filename_language_table[i].lang = lang;
1890     }
1891 }
1892
1893 static void
1894 info_ext_lang_command (args, from_tty)
1895      char *args;
1896      int from_tty;
1897 {
1898   int i;
1899
1900   printf_filtered ("Filename extensions and the languages they represent:");
1901   printf_filtered ("\n\n");
1902   for (i = 0; i < fl_table_next; i++)
1903     printf_filtered ("\t%s\t- %s\n",
1904                      filename_language_table[i].ext,
1905                      language_str (filename_language_table[i].lang));
1906 }
1907
1908 static void
1909 init_filename_language_table ()
1910 {
1911   if (fl_table_size == 0)       /* protect against repetition */
1912     {
1913       fl_table_size = 20;
1914       fl_table_next = 0;
1915       filename_language_table =
1916         xmalloc (fl_table_size * sizeof (*filename_language_table));
1917       add_filename_language (".c", language_c);
1918       add_filename_language (".C", language_cplus);
1919       add_filename_language (".cc", language_cplus);
1920       add_filename_language (".cp", language_cplus);
1921       add_filename_language (".cpp", language_cplus);
1922       add_filename_language (".cxx", language_cplus);
1923       add_filename_language (".c++", language_cplus);
1924       add_filename_language (".java", language_java);
1925       add_filename_language (".class", language_java);
1926       add_filename_language (".ch", language_chill);
1927       add_filename_language (".c186", language_chill);
1928       add_filename_language (".c286", language_chill);
1929       add_filename_language (".f", language_fortran);
1930       add_filename_language (".F", language_fortran);
1931       add_filename_language (".s", language_asm);
1932       add_filename_language (".S", language_asm);
1933     }
1934 }
1935
1936 enum language
1937 deduce_language_from_filename (filename)
1938      char *filename;
1939 {
1940   int i;
1941   char *cp;
1942
1943   if (filename != NULL)
1944     if ((cp = strrchr (filename, '.')) != NULL)
1945       for (i = 0; i < fl_table_next; i++)
1946         if (strcmp (cp, filename_language_table[i].ext) == 0)
1947           return filename_language_table[i].lang;
1948
1949   return language_unknown;
1950 }
1951 \f
1952 /* allocate_symtab:
1953
1954    Allocate and partly initialize a new symbol table.  Return a pointer
1955    to it.  error() if no space.
1956
1957    Caller must set these fields:
1958    LINETABLE(symtab)
1959    symtab->blockvector
1960    symtab->dirname
1961    symtab->free_code
1962    symtab->free_ptr
1963    possibly free_named_symtabs (symtab->filename);
1964  */
1965
1966 struct symtab *
1967 allocate_symtab (filename, objfile)
1968      char *filename;
1969      struct objfile *objfile;
1970 {
1971   register struct symtab *symtab;
1972
1973   symtab = (struct symtab *)
1974     obstack_alloc (&objfile->symbol_obstack, sizeof (struct symtab));
1975   memset (symtab, 0, sizeof (*symtab));
1976   symtab->filename = obsavestring (filename, strlen (filename),
1977                                    &objfile->symbol_obstack);
1978   symtab->fullname = NULL;
1979   symtab->language = deduce_language_from_filename (filename);
1980   symtab->debugformat = obsavestring ("unknown", 7,
1981                                       &objfile->symbol_obstack);
1982
1983   /* Hook it to the objfile it comes from */
1984
1985   symtab->objfile = objfile;
1986   symtab->next = objfile->symtabs;
1987   objfile->symtabs = symtab;
1988
1989   /* FIXME: This should go away.  It is only defined for the Z8000,
1990      and the Z8000 definition of this macro doesn't have anything to
1991      do with the now-nonexistent EXTRA_SYMTAB_INFO macro, it's just
1992      here for convenience.  */
1993 #ifdef INIT_EXTRA_SYMTAB_INFO
1994   INIT_EXTRA_SYMTAB_INFO (symtab);
1995 #endif
1996
1997   return (symtab);
1998 }
1999
2000 struct partial_symtab *
2001 allocate_psymtab (filename, objfile)
2002      char *filename;
2003      struct objfile *objfile;
2004 {
2005   struct partial_symtab *psymtab;
2006
2007   if (objfile->free_psymtabs)
2008     {
2009       psymtab = objfile->free_psymtabs;
2010       objfile->free_psymtabs = psymtab->next;
2011     }
2012   else
2013     psymtab = (struct partial_symtab *)
2014       obstack_alloc (&objfile->psymbol_obstack,
2015                      sizeof (struct partial_symtab));
2016
2017   memset (psymtab, 0, sizeof (struct partial_symtab));
2018   psymtab->filename = obsavestring (filename, strlen (filename),
2019                                     &objfile->psymbol_obstack);
2020   psymtab->symtab = NULL;
2021
2022   /* Prepend it to the psymtab list for the objfile it belongs to.
2023      Psymtabs are searched in most recent inserted -> least recent
2024      inserted order. */
2025
2026   psymtab->objfile = objfile;
2027   psymtab->next = objfile->psymtabs;
2028   objfile->psymtabs = psymtab;
2029 #if 0
2030   {
2031     struct partial_symtab **prev_pst;
2032     psymtab->objfile = objfile;
2033     psymtab->next = NULL;
2034     prev_pst = &(objfile->psymtabs);
2035     while ((*prev_pst) != NULL)
2036       prev_pst = &((*prev_pst)->next);
2037     (*prev_pst) = psymtab;
2038   }
2039 #endif
2040
2041   return (psymtab);
2042 }
2043
2044 void
2045 discard_psymtab (pst)
2046      struct partial_symtab *pst;
2047 {
2048   struct partial_symtab **prev_pst;
2049
2050   /* From dbxread.c:
2051      Empty psymtabs happen as a result of header files which don't
2052      have any symbols in them.  There can be a lot of them.  But this
2053      check is wrong, in that a psymtab with N_SLINE entries but
2054      nothing else is not empty, but we don't realize that.  Fixing
2055      that without slowing things down might be tricky.  */
2056
2057   /* First, snip it out of the psymtab chain */
2058
2059   prev_pst = &(pst->objfile->psymtabs);
2060   while ((*prev_pst) != pst)
2061     prev_pst = &((*prev_pst)->next);
2062   (*prev_pst) = pst->next;
2063
2064   /* Next, put it on a free list for recycling */
2065
2066   pst->next = pst->objfile->free_psymtabs;
2067   pst->objfile->free_psymtabs = pst;
2068 }
2069 \f
2070
2071 /* Reset all data structures in gdb which may contain references to symbol
2072    table data.  */
2073
2074 void
2075 clear_symtab_users ()
2076 {
2077   /* Someday, we should do better than this, by only blowing away
2078      the things that really need to be blown.  */
2079   clear_value_history ();
2080   clear_displays ();
2081   clear_internalvars ();
2082   breakpoint_re_set ();
2083   set_default_breakpoint (0, 0, 0, 0);
2084   current_source_symtab = 0;
2085   current_source_line = 0;
2086   clear_pc_function_cache ();
2087   if (target_new_objfile_hook)
2088     target_new_objfile_hook (NULL);
2089 }
2090
2091 static void
2092 clear_symtab_users_cleanup (void *ignore)
2093 {
2094   clear_symtab_users ();
2095 }
2096
2097 /* clear_symtab_users_once:
2098
2099    This function is run after symbol reading, or from a cleanup.
2100    If an old symbol table was obsoleted, the old symbol table
2101    has been blown away, but the other GDB data structures that may
2102    reference it have not yet been cleared or re-directed.  (The old
2103    symtab was zapped, and the cleanup queued, in free_named_symtab()
2104    below.)
2105
2106    This function can be queued N times as a cleanup, or called
2107    directly; it will do all the work the first time, and then will be a
2108    no-op until the next time it is queued.  This works by bumping a
2109    counter at queueing time.  Much later when the cleanup is run, or at
2110    the end of symbol processing (in case the cleanup is discarded), if
2111    the queued count is greater than the "done-count", we do the work
2112    and set the done-count to the queued count.  If the queued count is
2113    less than or equal to the done-count, we just ignore the call.  This
2114    is needed because reading a single .o file will often replace many
2115    symtabs (one per .h file, for example), and we don't want to reset
2116    the breakpoints N times in the user's face.
2117
2118    The reason we both queue a cleanup, and call it directly after symbol
2119    reading, is because the cleanup protects us in case of errors, but is
2120    discarded if symbol reading is successful.  */
2121
2122 #if 0
2123 /* FIXME:  As free_named_symtabs is currently a big noop this function
2124    is no longer needed.  */
2125 static void clear_symtab_users_once (void);
2126
2127 static int clear_symtab_users_queued;
2128 static int clear_symtab_users_done;
2129
2130 static void
2131 clear_symtab_users_once ()
2132 {
2133   /* Enforce once-per-`do_cleanups'-semantics */
2134   if (clear_symtab_users_queued <= clear_symtab_users_done)
2135     return;
2136   clear_symtab_users_done = clear_symtab_users_queued;
2137
2138   clear_symtab_users ();
2139 }
2140 #endif
2141
2142 /* Delete the specified psymtab, and any others that reference it.  */
2143
2144 static void
2145 cashier_psymtab (pst)
2146      struct partial_symtab *pst;
2147 {
2148   struct partial_symtab *ps, *pprev = NULL;
2149   int i;
2150
2151   /* Find its previous psymtab in the chain */
2152   for (ps = pst->objfile->psymtabs; ps; ps = ps->next)
2153     {
2154       if (ps == pst)
2155         break;
2156       pprev = ps;
2157     }
2158
2159   if (ps)
2160     {
2161       /* Unhook it from the chain.  */
2162       if (ps == pst->objfile->psymtabs)
2163         pst->objfile->psymtabs = ps->next;
2164       else
2165         pprev->next = ps->next;
2166
2167       /* FIXME, we can't conveniently deallocate the entries in the
2168          partial_symbol lists (global_psymbols/static_psymbols) that
2169          this psymtab points to.  These just take up space until all
2170          the psymtabs are reclaimed.  Ditto the dependencies list and
2171          filename, which are all in the psymbol_obstack.  */
2172
2173       /* We need to cashier any psymtab that has this one as a dependency... */
2174     again:
2175       for (ps = pst->objfile->psymtabs; ps; ps = ps->next)
2176         {
2177           for (i = 0; i < ps->number_of_dependencies; i++)
2178             {
2179               if (ps->dependencies[i] == pst)
2180                 {
2181                   cashier_psymtab (ps);
2182                   goto again;   /* Must restart, chain has been munged. */
2183                 }
2184             }
2185         }
2186     }
2187 }
2188
2189 /* If a symtab or psymtab for filename NAME is found, free it along
2190    with any dependent breakpoints, displays, etc.
2191    Used when loading new versions of object modules with the "add-file"
2192    command.  This is only called on the top-level symtab or psymtab's name;
2193    it is not called for subsidiary files such as .h files.
2194
2195    Return value is 1 if we blew away the environment, 0 if not.
2196    FIXME.  The return valu appears to never be used.
2197
2198    FIXME.  I think this is not the best way to do this.  We should
2199    work on being gentler to the environment while still cleaning up
2200    all stray pointers into the freed symtab.  */
2201
2202 int
2203 free_named_symtabs (name)
2204      char *name;
2205 {
2206 #if 0
2207   /* FIXME:  With the new method of each objfile having it's own
2208      psymtab list, this function needs serious rethinking.  In particular,
2209      why was it ever necessary to toss psymtabs with specific compilation
2210      unit filenames, as opposed to all psymtabs from a particular symbol
2211      file?  -- fnf
2212      Well, the answer is that some systems permit reloading of particular
2213      compilation units.  We want to blow away any old info about these
2214      compilation units, regardless of which objfiles they arrived in. --gnu.  */
2215
2216   register struct symtab *s;
2217   register struct symtab *prev;
2218   register struct partial_symtab *ps;
2219   struct blockvector *bv;
2220   int blewit = 0;
2221
2222   /* We only wack things if the symbol-reload switch is set.  */
2223   if (!symbol_reloading)
2224     return 0;
2225
2226   /* Some symbol formats have trouble providing file names... */
2227   if (name == 0 || *name == '\0')
2228     return 0;
2229
2230   /* Look for a psymtab with the specified name.  */
2231
2232 again2:
2233   for (ps = partial_symtab_list; ps; ps = ps->next)
2234     {
2235       if (STREQ (name, ps->filename))
2236         {
2237           cashier_psymtab (ps); /* Blow it away...and its little dog, too.  */
2238           goto again2;          /* Must restart, chain has been munged */
2239         }
2240     }
2241
2242   /* Look for a symtab with the specified name.  */
2243
2244   for (s = symtab_list; s; s = s->next)
2245     {
2246       if (STREQ (name, s->filename))
2247         break;
2248       prev = s;
2249     }
2250
2251   if (s)
2252     {
2253       if (s == symtab_list)
2254         symtab_list = s->next;
2255       else
2256         prev->next = s->next;
2257
2258       /* For now, queue a delete for all breakpoints, displays, etc., whether
2259          or not they depend on the symtab being freed.  This should be
2260          changed so that only those data structures affected are deleted.  */
2261
2262       /* But don't delete anything if the symtab is empty.
2263          This test is necessary due to a bug in "dbxread.c" that
2264          causes empty symtabs to be created for N_SO symbols that
2265          contain the pathname of the object file.  (This problem
2266          has been fixed in GDB 3.9x).  */
2267
2268       bv = BLOCKVECTOR (s);
2269       if (BLOCKVECTOR_NBLOCKS (bv) > 2
2270           || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK))
2271           || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)))
2272         {
2273           complain (&oldsyms_complaint, name);
2274
2275           clear_symtab_users_queued++;
2276           make_cleanup (clear_symtab_users_once, 0);
2277           blewit = 1;
2278         }
2279       else
2280         {
2281           complain (&empty_symtab_complaint, name);
2282         }
2283
2284       free_symtab (s);
2285     }
2286   else
2287     {
2288       /* It is still possible that some breakpoints will be affected
2289          even though no symtab was found, since the file might have
2290          been compiled without debugging, and hence not be associated
2291          with a symtab.  In order to handle this correctly, we would need
2292          to keep a list of text address ranges for undebuggable files.
2293          For now, we do nothing, since this is a fairly obscure case.  */
2294       ;
2295     }
2296
2297   /* FIXME, what about the minimal symbol table? */
2298   return blewit;
2299 #else
2300   return (0);
2301 #endif
2302 }
2303 \f
2304 /* Allocate and partially fill a partial symtab.  It will be
2305    completely filled at the end of the symbol list.
2306
2307    FILENAME is the name of the symbol-file we are reading from. */
2308
2309 struct partial_symtab *
2310 start_psymtab_common (objfile, section_offsets,
2311                       filename, textlow, global_syms, static_syms)
2312      struct objfile *objfile;
2313      struct section_offsets *section_offsets;
2314      char *filename;
2315      CORE_ADDR textlow;
2316      struct partial_symbol **global_syms;
2317      struct partial_symbol **static_syms;
2318 {
2319   struct partial_symtab *psymtab;
2320
2321   psymtab = allocate_psymtab (filename, objfile);
2322   psymtab->section_offsets = section_offsets;
2323   psymtab->textlow = textlow;
2324   psymtab->texthigh = psymtab->textlow;         /* default */
2325   psymtab->globals_offset = global_syms - objfile->global_psymbols.list;
2326   psymtab->statics_offset = static_syms - objfile->static_psymbols.list;
2327   return (psymtab);
2328 }
2329 \f
2330 /* Add a symbol with a long value to a psymtab.
2331    Since one arg is a struct, we pass in a ptr and deref it (sigh).  */
2332
2333 void
2334 add_psymbol_to_list (name, namelength, namespace, class, list, val, coreaddr,
2335                      language, objfile)
2336      char *name;
2337      int namelength;
2338      namespace_enum namespace;
2339      enum address_class class;
2340      struct psymbol_allocation_list *list;
2341      long val;                  /* Value as a long */
2342      CORE_ADDR coreaddr;        /* Value as a CORE_ADDR */
2343      enum language language;
2344      struct objfile *objfile;
2345 {
2346   register struct partial_symbol *psym;
2347   char *buf = alloca (namelength + 1);
2348   /* psymbol is static so that there will be no uninitialized gaps in the
2349      structure which might contain random data, causing cache misses in
2350      bcache. */
2351   static struct partial_symbol psymbol;
2352
2353   /* Create local copy of the partial symbol */
2354   memcpy (buf, name, namelength);
2355   buf[namelength] = '\0';
2356   SYMBOL_NAME (&psymbol) = bcache (buf, namelength + 1, &objfile->psymbol_cache);
2357   /* val and coreaddr are mutually exclusive, one of them *will* be zero */
2358   if (val != 0)
2359     {
2360       SYMBOL_VALUE (&psymbol) = val;
2361     }
2362   else
2363     {
2364       SYMBOL_VALUE_ADDRESS (&psymbol) = coreaddr;
2365     }
2366   SYMBOL_SECTION (&psymbol) = 0;
2367   SYMBOL_LANGUAGE (&psymbol) = language;
2368   PSYMBOL_NAMESPACE (&psymbol) = namespace;
2369   PSYMBOL_CLASS (&psymbol) = class;
2370   SYMBOL_INIT_LANGUAGE_SPECIFIC (&psymbol, language);
2371
2372   /* Stash the partial symbol away in the cache */
2373   psym = bcache (&psymbol, sizeof (struct partial_symbol), &objfile->psymbol_cache);
2374
2375   /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
2376   if (list->next >= list->list + list->size)
2377     {
2378       extend_psymbol_list (list, objfile);
2379     }
2380   *list->next++ = psym;
2381   OBJSTAT (objfile, n_psyms++);
2382 }
2383
2384 /* Add a symbol with a long value to a psymtab. This differs from
2385  * add_psymbol_to_list above in taking both a mangled and a demangled
2386  * name. */
2387
2388 void
2389 add_psymbol_with_dem_name_to_list (name, namelength, dem_name, dem_namelength,
2390                    namespace, class, list, val, coreaddr, language, objfile)
2391      char *name;
2392      int namelength;
2393      char *dem_name;
2394      int dem_namelength;
2395      namespace_enum namespace;
2396      enum address_class class;
2397      struct psymbol_allocation_list *list;
2398      long val;                  /* Value as a long */
2399      CORE_ADDR coreaddr;        /* Value as a CORE_ADDR */
2400      enum language language;
2401      struct objfile *objfile;
2402 {
2403   register struct partial_symbol *psym;
2404   char *buf = alloca (namelength + 1);
2405   /* psymbol is static so that there will be no uninitialized gaps in the
2406      structure which might contain random data, causing cache misses in
2407      bcache. */
2408   static struct partial_symbol psymbol;
2409
2410   /* Create local copy of the partial symbol */
2411
2412   memcpy (buf, name, namelength);
2413   buf[namelength] = '\0';
2414   SYMBOL_NAME (&psymbol) = bcache (buf, namelength + 1, &objfile->psymbol_cache);
2415
2416   buf = alloca (dem_namelength + 1);
2417   memcpy (buf, dem_name, dem_namelength);
2418   buf[dem_namelength] = '\0';
2419
2420   switch (language)
2421     {
2422     case language_c:
2423     case language_cplus:
2424       SYMBOL_CPLUS_DEMANGLED_NAME (&psymbol) =
2425         bcache (buf, dem_namelength + 1, &objfile->psymbol_cache);
2426       break;
2427     case language_chill:
2428       SYMBOL_CHILL_DEMANGLED_NAME (&psymbol) =
2429         bcache (buf, dem_namelength + 1, &objfile->psymbol_cache);
2430
2431       /* FIXME What should be done for the default case? Ignoring for now. */
2432     }
2433
2434   /* val and coreaddr are mutually exclusive, one of them *will* be zero */
2435   if (val != 0)
2436     {
2437       SYMBOL_VALUE (&psymbol) = val;
2438     }
2439   else
2440     {
2441       SYMBOL_VALUE_ADDRESS (&psymbol) = coreaddr;
2442     }
2443   SYMBOL_SECTION (&psymbol) = 0;
2444   SYMBOL_LANGUAGE (&psymbol) = language;
2445   PSYMBOL_NAMESPACE (&psymbol) = namespace;
2446   PSYMBOL_CLASS (&psymbol) = class;
2447   SYMBOL_INIT_LANGUAGE_SPECIFIC (&psymbol, language);
2448
2449   /* Stash the partial symbol away in the cache */
2450   psym = bcache (&psymbol, sizeof (struct partial_symbol), &objfile->psymbol_cache);
2451
2452   /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
2453   if (list->next >= list->list + list->size)
2454     {
2455       extend_psymbol_list (list, objfile);
2456     }
2457   *list->next++ = psym;
2458   OBJSTAT (objfile, n_psyms++);
2459 }
2460
2461 /* Initialize storage for partial symbols.  */
2462
2463 void
2464 init_psymbol_list (objfile, total_symbols)
2465      struct objfile *objfile;
2466      int total_symbols;
2467 {
2468   /* Free any previously allocated psymbol lists.  */
2469
2470   if (objfile->global_psymbols.list)
2471     {
2472       mfree (objfile->md, (PTR) objfile->global_psymbols.list);
2473     }
2474   if (objfile->static_psymbols.list)
2475     {
2476       mfree (objfile->md, (PTR) objfile->static_psymbols.list);
2477     }
2478
2479   /* Current best guess is that approximately a twentieth
2480      of the total symbols (in a debugging file) are global or static
2481      oriented symbols */
2482
2483   objfile->global_psymbols.size = total_symbols / 10;
2484   objfile->static_psymbols.size = total_symbols / 10;
2485
2486   if (objfile->global_psymbols.size > 0)
2487     {
2488       objfile->global_psymbols.next =
2489         objfile->global_psymbols.list = (struct partial_symbol **)
2490         xmmalloc (objfile->md, (objfile->global_psymbols.size
2491                                 * sizeof (struct partial_symbol *)));
2492     }
2493   if (objfile->static_psymbols.size > 0)
2494     {
2495       objfile->static_psymbols.next =
2496         objfile->static_psymbols.list = (struct partial_symbol **)
2497         xmmalloc (objfile->md, (objfile->static_psymbols.size
2498                                 * sizeof (struct partial_symbol *)));
2499     }
2500 }
2501
2502 /* OVERLAYS:
2503    The following code implements an abstraction for debugging overlay sections.
2504
2505    The target model is as follows:
2506    1) The gnu linker will permit multiple sections to be mapped into the
2507    same VMA, each with its own unique LMA (or load address).
2508    2) It is assumed that some runtime mechanism exists for mapping the
2509    sections, one by one, from the load address into the VMA address.
2510    3) This code provides a mechanism for gdb to keep track of which
2511    sections should be considered to be mapped from the VMA to the LMA.
2512    This information is used for symbol lookup, and memory read/write.
2513    For instance, if a section has been mapped then its contents
2514    should be read from the VMA, otherwise from the LMA.
2515
2516    Two levels of debugger support for overlays are available.  One is
2517    "manual", in which the debugger relies on the user to tell it which
2518    overlays are currently mapped.  This level of support is
2519    implemented entirely in the core debugger, and the information about
2520    whether a section is mapped is kept in the objfile->obj_section table.
2521
2522    The second level of support is "automatic", and is only available if
2523    the target-specific code provides functionality to read the target's
2524    overlay mapping table, and translate its contents for the debugger
2525    (by updating the mapped state information in the obj_section tables).
2526
2527    The interface is as follows:
2528    User commands:
2529    overlay map <name>   -- tell gdb to consider this section mapped
2530    overlay unmap <name> -- tell gdb to consider this section unmapped
2531    overlay list         -- list the sections that GDB thinks are mapped
2532    overlay read-target  -- get the target's state of what's mapped
2533    overlay off/manual/auto -- set overlay debugging state
2534    Functional interface:
2535    find_pc_mapped_section(pc):    if the pc is in the range of a mapped
2536    section, return that section.
2537    find_pc_overlay(pc):       find any overlay section that contains
2538    the pc, either in its VMA or its LMA
2539    overlay_is_mapped(sect):       true if overlay is marked as mapped
2540    section_is_overlay(sect):      true if section's VMA != LMA
2541    pc_in_mapped_range(pc,sec):    true if pc belongs to section's VMA
2542    pc_in_unmapped_range(...):     true if pc belongs to section's LMA
2543    overlay_mapped_address(...):   map an address from section's LMA to VMA
2544    overlay_unmapped_address(...): map an address from section's VMA to LMA
2545    symbol_overlayed_address(...): Return a "current" address for symbol:
2546    either in VMA or LMA depending on whether
2547    the symbol's section is currently mapped
2548  */
2549
2550 /* Overlay debugging state: */
2551
2552 int overlay_debugging = 0;      /* 0 == off, 1 == manual, -1 == auto */
2553 int overlay_cache_invalid = 0;  /* True if need to refresh mapped state */
2554
2555 /* Target vector for refreshing overlay mapped state */
2556 static void simple_overlay_update (struct obj_section *);
2557 void (*target_overlay_update) (struct obj_section *) = simple_overlay_update;
2558
2559 /* Function: section_is_overlay (SECTION)
2560    Returns true if SECTION has VMA not equal to LMA, ie.
2561    SECTION is loaded at an address different from where it will "run".  */
2562
2563 int
2564 section_is_overlay (section)
2565      asection *section;
2566 {
2567   if (overlay_debugging)
2568     if (section && section->lma != 0 &&
2569         section->vma != section->lma)
2570       return 1;
2571
2572   return 0;
2573 }
2574
2575 /* Function: overlay_invalidate_all (void)
2576    Invalidate the mapped state of all overlay sections (mark it as stale).  */
2577
2578 static void
2579 overlay_invalidate_all ()
2580 {
2581   struct objfile *objfile;
2582   struct obj_section *sect;
2583
2584   ALL_OBJSECTIONS (objfile, sect)
2585     if (section_is_overlay (sect->the_bfd_section))
2586     sect->ovly_mapped = -1;
2587 }
2588
2589 /* Function: overlay_is_mapped (SECTION)
2590    Returns true if section is an overlay, and is currently mapped.
2591    Private: public access is thru function section_is_mapped.
2592
2593    Access to the ovly_mapped flag is restricted to this function, so
2594    that we can do automatic update.  If the global flag
2595    OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
2596    overlay_invalidate_all.  If the mapped state of the particular
2597    section is stale, then call TARGET_OVERLAY_UPDATE to refresh it.  */
2598
2599 static int
2600 overlay_is_mapped (osect)
2601      struct obj_section *osect;
2602 {
2603   if (osect == 0 || !section_is_overlay (osect->the_bfd_section))
2604     return 0;
2605
2606   switch (overlay_debugging)
2607     {
2608     default:
2609     case 0:
2610       return 0;                 /* overlay debugging off */
2611     case -1:                    /* overlay debugging automatic */
2612       /* Unles there is a target_overlay_update function,
2613          there's really nothing useful to do here (can't really go auto)  */
2614       if (target_overlay_update)
2615         {
2616           if (overlay_cache_invalid)
2617             {
2618               overlay_invalidate_all ();
2619               overlay_cache_invalid = 0;
2620             }
2621           if (osect->ovly_mapped == -1)
2622             (*target_overlay_update) (osect);
2623         }
2624       /* fall thru to manual case */
2625     case 1:                     /* overlay debugging manual */
2626       return osect->ovly_mapped == 1;
2627     }
2628 }
2629
2630 /* Function: section_is_mapped
2631    Returns true if section is an overlay, and is currently mapped.  */
2632
2633 int
2634 section_is_mapped (section)
2635      asection *section;
2636 {
2637   struct objfile *objfile;
2638   struct obj_section *osect;
2639
2640   if (overlay_debugging)
2641     if (section && section_is_overlay (section))
2642       ALL_OBJSECTIONS (objfile, osect)
2643         if (osect->the_bfd_section == section)
2644         return overlay_is_mapped (osect);
2645
2646   return 0;
2647 }
2648
2649 /* Function: pc_in_unmapped_range
2650    If PC falls into the lma range of SECTION, return true, else false.  */
2651
2652 CORE_ADDR
2653 pc_in_unmapped_range (pc, section)
2654      CORE_ADDR pc;
2655      asection *section;
2656 {
2657   int size;
2658
2659   if (overlay_debugging)
2660     if (section && section_is_overlay (section))
2661       {
2662         size = bfd_get_section_size_before_reloc (section);
2663         if (section->lma <= pc && pc < section->lma + size)
2664           return 1;
2665       }
2666   return 0;
2667 }
2668
2669 /* Function: pc_in_mapped_range
2670    If PC falls into the vma range of SECTION, return true, else false.  */
2671
2672 CORE_ADDR
2673 pc_in_mapped_range (pc, section)
2674      CORE_ADDR pc;
2675      asection *section;
2676 {
2677   int size;
2678
2679   if (overlay_debugging)
2680     if (section && section_is_overlay (section))
2681       {
2682         size = bfd_get_section_size_before_reloc (section);
2683         if (section->vma <= pc && pc < section->vma + size)
2684           return 1;
2685       }
2686   return 0;
2687 }
2688
2689 /* Function: overlay_unmapped_address (PC, SECTION)
2690    Returns the address corresponding to PC in the unmapped (load) range.
2691    May be the same as PC.  */
2692
2693 CORE_ADDR
2694 overlay_unmapped_address (pc, section)
2695      CORE_ADDR pc;
2696      asection *section;
2697 {
2698   if (overlay_debugging)
2699     if (section && section_is_overlay (section) &&
2700         pc_in_mapped_range (pc, section))
2701       return pc + section->lma - section->vma;
2702
2703   return pc;
2704 }
2705
2706 /* Function: overlay_mapped_address (PC, SECTION)
2707    Returns the address corresponding to PC in the mapped (runtime) range.
2708    May be the same as PC.  */
2709
2710 CORE_ADDR
2711 overlay_mapped_address (pc, section)
2712      CORE_ADDR pc;
2713      asection *section;
2714 {
2715   if (overlay_debugging)
2716     if (section && section_is_overlay (section) &&
2717         pc_in_unmapped_range (pc, section))
2718       return pc + section->vma - section->lma;
2719
2720   return pc;
2721 }
2722
2723
2724 /* Function: symbol_overlayed_address
2725    Return one of two addresses (relative to the VMA or to the LMA),
2726    depending on whether the section is mapped or not.  */
2727
2728 CORE_ADDR
2729 symbol_overlayed_address (address, section)
2730      CORE_ADDR address;
2731      asection *section;
2732 {
2733   if (overlay_debugging)
2734     {
2735       /* If the symbol has no section, just return its regular address. */
2736       if (section == 0)
2737         return address;
2738       /* If the symbol's section is not an overlay, just return its address */
2739       if (!section_is_overlay (section))
2740         return address;
2741       /* If the symbol's section is mapped, just return its address */
2742       if (section_is_mapped (section))
2743         return address;
2744       /*
2745        * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
2746        * then return its LOADED address rather than its vma address!!
2747        */
2748       return overlay_unmapped_address (address, section);
2749     }
2750   return address;
2751 }
2752
2753 /* Function: find_pc_overlay (PC)
2754    Return the best-match overlay section for PC:
2755    If PC matches a mapped overlay section's VMA, return that section.
2756    Else if PC matches an unmapped section's VMA, return that section.
2757    Else if PC matches an unmapped section's LMA, return that section.  */
2758
2759 asection *
2760 find_pc_overlay (pc)
2761      CORE_ADDR pc;
2762 {
2763   struct objfile *objfile;
2764   struct obj_section *osect, *best_match = NULL;
2765
2766   if (overlay_debugging)
2767     ALL_OBJSECTIONS (objfile, osect)
2768       if (section_is_overlay (osect->the_bfd_section))
2769       {
2770         if (pc_in_mapped_range (pc, osect->the_bfd_section))
2771           {
2772             if (overlay_is_mapped (osect))
2773               return osect->the_bfd_section;
2774             else
2775               best_match = osect;
2776           }
2777         else if (pc_in_unmapped_range (pc, osect->the_bfd_section))
2778           best_match = osect;
2779       }
2780   return best_match ? best_match->the_bfd_section : NULL;
2781 }
2782
2783 /* Function: find_pc_mapped_section (PC)
2784    If PC falls into the VMA address range of an overlay section that is
2785    currently marked as MAPPED, return that section.  Else return NULL.  */
2786
2787 asection *
2788 find_pc_mapped_section (pc)
2789      CORE_ADDR pc;
2790 {
2791   struct objfile *objfile;
2792   struct obj_section *osect;
2793
2794   if (overlay_debugging)
2795     ALL_OBJSECTIONS (objfile, osect)
2796       if (pc_in_mapped_range (pc, osect->the_bfd_section) &&
2797           overlay_is_mapped (osect))
2798       return osect->the_bfd_section;
2799
2800   return NULL;
2801 }
2802
2803 /* Function: list_overlays_command
2804    Print a list of mapped sections and their PC ranges */
2805
2806 void
2807 list_overlays_command (args, from_tty)
2808      char *args;
2809      int from_tty;
2810 {
2811   int nmapped = 0;
2812   struct objfile *objfile;
2813   struct obj_section *osect;
2814
2815   if (overlay_debugging)
2816     ALL_OBJSECTIONS (objfile, osect)
2817       if (overlay_is_mapped (osect))
2818       {
2819         const char *name;
2820         bfd_vma lma, vma;
2821         int size;
2822
2823         vma = bfd_section_vma (objfile->obfd, osect->the_bfd_section);
2824         lma = bfd_section_lma (objfile->obfd, osect->the_bfd_section);
2825         size = bfd_get_section_size_before_reloc (osect->the_bfd_section);
2826         name = bfd_section_name (objfile->obfd, osect->the_bfd_section);
2827
2828         printf_filtered ("Section %s, loaded at ", name);
2829         print_address_numeric (lma, 1, gdb_stdout);
2830         puts_filtered (" - ");
2831         print_address_numeric (lma + size, 1, gdb_stdout);
2832         printf_filtered (", mapped at ");
2833         print_address_numeric (vma, 1, gdb_stdout);
2834         puts_filtered (" - ");
2835         print_address_numeric (vma + size, 1, gdb_stdout);
2836         puts_filtered ("\n");
2837
2838         nmapped++;
2839       }
2840   if (nmapped == 0)
2841     printf_filtered ("No sections are mapped.\n");
2842 }
2843
2844 /* Function: map_overlay_command
2845    Mark the named section as mapped (ie. residing at its VMA address).  */
2846
2847 void
2848 map_overlay_command (args, from_tty)
2849      char *args;
2850      int from_tty;
2851 {
2852   struct objfile *objfile, *objfile2;
2853   struct obj_section *sec, *sec2;
2854   asection *bfdsec;
2855
2856   if (!overlay_debugging)
2857     error ("\
2858 Overlay debugging not enabled.  Use either the 'overlay auto' or\n\
2859 the 'overlay manual' command.");
2860
2861   if (args == 0 || *args == 0)
2862     error ("Argument required: name of an overlay section");
2863
2864   /* First, find a section matching the user supplied argument */
2865   ALL_OBJSECTIONS (objfile, sec)
2866     if (!strcmp (bfd_section_name (objfile->obfd, sec->the_bfd_section), args))
2867     {
2868       /* Now, check to see if the section is an overlay. */
2869       bfdsec = sec->the_bfd_section;
2870       if (!section_is_overlay (bfdsec))
2871         continue;               /* not an overlay section */
2872
2873       /* Mark the overlay as "mapped" */
2874       sec->ovly_mapped = 1;
2875
2876       /* Next, make a pass and unmap any sections that are
2877          overlapped by this new section: */
2878       ALL_OBJSECTIONS (objfile2, sec2)
2879         if (sec2->ovly_mapped &&
2880             sec != sec2 &&
2881             sec->the_bfd_section != sec2->the_bfd_section &&
2882             (pc_in_mapped_range (sec2->addr, sec->the_bfd_section) ||
2883              pc_in_mapped_range (sec2->endaddr, sec->the_bfd_section)))
2884         {
2885           if (info_verbose)
2886             printf_filtered ("Note: section %s unmapped by overlap\n",
2887                              bfd_section_name (objfile->obfd,
2888                                                sec2->the_bfd_section));
2889           sec2->ovly_mapped = 0;        /* sec2 overlaps sec: unmap sec2 */
2890         }
2891       return;
2892     }
2893   error ("No overlay section called %s", args);
2894 }
2895
2896 /* Function: unmap_overlay_command
2897    Mark the overlay section as unmapped
2898    (ie. resident in its LMA address range, rather than the VMA range).  */
2899
2900 void
2901 unmap_overlay_command (args, from_tty)
2902      char *args;
2903      int from_tty;
2904 {
2905   struct objfile *objfile;
2906   struct obj_section *sec;
2907
2908   if (!overlay_debugging)
2909     error ("\
2910 Overlay debugging not enabled.  Use either the 'overlay auto' or\n\
2911 the 'overlay manual' command.");
2912
2913   if (args == 0 || *args == 0)
2914     error ("Argument required: name of an overlay section");
2915
2916   /* First, find a section matching the user supplied argument */
2917   ALL_OBJSECTIONS (objfile, sec)
2918     if (!strcmp (bfd_section_name (objfile->obfd, sec->the_bfd_section), args))
2919     {
2920       if (!sec->ovly_mapped)
2921         error ("Section %s is not mapped", args);
2922       sec->ovly_mapped = 0;
2923       return;
2924     }
2925   error ("No overlay section called %s", args);
2926 }
2927
2928 /* Function: overlay_auto_command
2929    A utility command to turn on overlay debugging.
2930    Possibly this should be done via a set/show command. */
2931
2932 static void
2933 overlay_auto_command (args, from_tty)
2934      char *args;
2935      int from_tty;
2936 {
2937   overlay_debugging = -1;
2938   if (info_verbose)
2939     printf_filtered ("Automatic overlay debugging enabled.");
2940 }
2941
2942 /* Function: overlay_manual_command
2943    A utility command to turn on overlay debugging.
2944    Possibly this should be done via a set/show command. */
2945
2946 static void
2947 overlay_manual_command (args, from_tty)
2948      char *args;
2949      int from_tty;
2950 {
2951   overlay_debugging = 1;
2952   if (info_verbose)
2953     printf_filtered ("Overlay debugging enabled.");
2954 }
2955
2956 /* Function: overlay_off_command
2957    A utility command to turn on overlay debugging.
2958    Possibly this should be done via a set/show command. */
2959
2960 static void
2961 overlay_off_command (args, from_tty)
2962      char *args;
2963      int from_tty;
2964 {
2965   overlay_debugging = 0;
2966   if (info_verbose)
2967     printf_filtered ("Overlay debugging disabled.");
2968 }
2969
2970 static void
2971 overlay_load_command (args, from_tty)
2972      char *args;
2973      int from_tty;
2974 {
2975   if (target_overlay_update)
2976     (*target_overlay_update) (NULL);
2977   else
2978     error ("This target does not know how to read its overlay state.");
2979 }
2980
2981 /* Function: overlay_command
2982    A place-holder for a mis-typed command */
2983
2984 /* Command list chain containing all defined "overlay" subcommands. */
2985 struct cmd_list_element *overlaylist;
2986
2987 static void
2988 overlay_command (args, from_tty)
2989      char *args;
2990      int from_tty;
2991 {
2992   printf_unfiltered
2993     ("\"overlay\" must be followed by the name of an overlay command.\n");
2994   help_list (overlaylist, "overlay ", -1, gdb_stdout);
2995 }
2996
2997
2998 /* Target Overlays for the "Simplest" overlay manager:
2999
3000    This is GDB's default target overlay layer.  It works with the
3001    minimal overlay manager supplied as an example by Cygnus.  The
3002    entry point is via a function pointer "target_overlay_update",
3003    so targets that use a different runtime overlay manager can
3004    substitute their own overlay_update function and take over the
3005    function pointer.
3006
3007    The overlay_update function pokes around in the target's data structures
3008    to see what overlays are mapped, and updates GDB's overlay mapping with
3009    this information.
3010
3011    In this simple implementation, the target data structures are as follows:
3012    unsigned _novlys;            /# number of overlay sections #/
3013    unsigned _ovly_table[_novlys][4] = {
3014    {VMA, SIZE, LMA, MAPPED},    /# one entry per overlay section #/
3015    {..., ...,  ..., ...},
3016    }
3017    unsigned _novly_regions;     /# number of overlay regions #/
3018    unsigned _ovly_region_table[_novly_regions][3] = {
3019    {VMA, SIZE, MAPPED_TO_LMA},  /# one entry per overlay region #/
3020    {..., ...,  ...},
3021    }
3022    These functions will attempt to update GDB's mappedness state in the
3023    symbol section table, based on the target's mappedness state.
3024
3025    To do this, we keep a cached copy of the target's _ovly_table, and
3026    attempt to detect when the cached copy is invalidated.  The main
3027    entry point is "simple_overlay_update(SECT), which looks up SECT in
3028    the cached table and re-reads only the entry for that section from
3029    the target (whenever possible).
3030  */
3031
3032 /* Cached, dynamically allocated copies of the target data structures: */
3033 static unsigned (*cache_ovly_table)[4] = 0;
3034 #if 0
3035 static unsigned (*cache_ovly_region_table)[3] = 0;
3036 #endif
3037 static unsigned cache_novlys = 0;
3038 #if 0
3039 static unsigned cache_novly_regions = 0;
3040 #endif
3041 static CORE_ADDR cache_ovly_table_base = 0;
3042 #if 0
3043 static CORE_ADDR cache_ovly_region_table_base = 0;
3044 #endif
3045 enum ovly_index
3046   {
3047     VMA, SIZE, LMA, MAPPED
3048   };
3049 #define TARGET_LONG_BYTES (TARGET_LONG_BIT / TARGET_CHAR_BIT)
3050
3051 /* Throw away the cached copy of _ovly_table */
3052 static void
3053 simple_free_overlay_table ()
3054 {
3055   if (cache_ovly_table)
3056     free (cache_ovly_table);
3057   cache_novlys = 0;
3058   cache_ovly_table = NULL;
3059   cache_ovly_table_base = 0;
3060 }
3061
3062 #if 0
3063 /* Throw away the cached copy of _ovly_region_table */
3064 static void
3065 simple_free_overlay_region_table ()
3066 {
3067   if (cache_ovly_region_table)
3068     free (cache_ovly_region_table);
3069   cache_novly_regions = 0;
3070   cache_ovly_region_table = NULL;
3071   cache_ovly_region_table_base = 0;
3072 }
3073 #endif
3074
3075 /* Read an array of ints from the target into a local buffer.
3076    Convert to host order.  int LEN is number of ints  */
3077 static void
3078 read_target_long_array (memaddr, myaddr, len)
3079      CORE_ADDR memaddr;
3080      unsigned int *myaddr;
3081      int len;
3082 {
3083   char *buf = alloca (len * TARGET_LONG_BYTES);
3084   int i;
3085
3086   read_memory (memaddr, buf, len * TARGET_LONG_BYTES);
3087   for (i = 0; i < len; i++)
3088     myaddr[i] = extract_unsigned_integer (TARGET_LONG_BYTES * i + buf,
3089                                           TARGET_LONG_BYTES);
3090 }
3091
3092 /* Find and grab a copy of the target _ovly_table
3093    (and _novlys, which is needed for the table's size) */
3094 static int
3095 simple_read_overlay_table ()
3096 {
3097   struct minimal_symbol *msym;
3098
3099   simple_free_overlay_table ();
3100   msym = lookup_minimal_symbol ("_novlys", 0, 0);
3101   if (msym != NULL)
3102     cache_novlys = read_memory_integer (SYMBOL_VALUE_ADDRESS (msym), 4);
3103   else
3104     return 0;                   /* failure */
3105   cache_ovly_table = (void *) xmalloc (cache_novlys * sizeof (*cache_ovly_table));
3106   if (cache_ovly_table != NULL)
3107     {
3108       msym = lookup_minimal_symbol ("_ovly_table", 0, 0);
3109       if (msym != NULL)
3110         {
3111           cache_ovly_table_base = SYMBOL_VALUE_ADDRESS (msym);
3112           read_target_long_array (cache_ovly_table_base,
3113                                   (int *) cache_ovly_table,
3114                                   cache_novlys * 4);
3115         }
3116       else
3117         return 0;               /* failure */
3118     }
3119   else
3120     return 0;                   /* failure */
3121   return 1;                     /* SUCCESS */
3122 }
3123
3124 #if 0
3125 /* Find and grab a copy of the target _ovly_region_table
3126    (and _novly_regions, which is needed for the table's size) */
3127 static int
3128 simple_read_overlay_region_table ()
3129 {
3130   struct minimal_symbol *msym;
3131
3132   simple_free_overlay_region_table ();
3133   msym = lookup_minimal_symbol ("_novly_regions", 0, 0);
3134   if (msym != NULL)
3135     cache_novly_regions = read_memory_integer (SYMBOL_VALUE_ADDRESS (msym), 4);
3136   else
3137     return 0;                   /* failure */
3138   cache_ovly_region_table = (void *) xmalloc (cache_novly_regions * 12);
3139   if (cache_ovly_region_table != NULL)
3140     {
3141       msym = lookup_minimal_symbol ("_ovly_region_table", 0, 0);
3142       if (msym != NULL)
3143         {
3144           cache_ovly_region_table_base = SYMBOL_VALUE_ADDRESS (msym);
3145           read_target_long_array (cache_ovly_region_table_base,
3146                                   (int *) cache_ovly_region_table,
3147                                   cache_novly_regions * 3);
3148         }
3149       else
3150         return 0;               /* failure */
3151     }
3152   else
3153     return 0;                   /* failure */
3154   return 1;                     /* SUCCESS */
3155 }
3156 #endif
3157
3158 /* Function: simple_overlay_update_1
3159    A helper function for simple_overlay_update.  Assuming a cached copy
3160    of _ovly_table exists, look through it to find an entry whose vma,
3161    lma and size match those of OSECT.  Re-read the entry and make sure
3162    it still matches OSECT (else the table may no longer be valid).
3163    Set OSECT's mapped state to match the entry.  Return: 1 for
3164    success, 0 for failure.  */
3165
3166 static int
3167 simple_overlay_update_1 (osect)
3168      struct obj_section *osect;
3169 {
3170   int i, size;
3171
3172   size = bfd_get_section_size_before_reloc (osect->the_bfd_section);
3173   for (i = 0; i < cache_novlys; i++)
3174     if (cache_ovly_table[i][VMA] == osect->the_bfd_section->vma &&
3175         cache_ovly_table[i][LMA] == osect->the_bfd_section->lma         /* &&
3176                                                                            cache_ovly_table[i][SIZE] == size */ )
3177       {
3178         read_target_long_array (cache_ovly_table_base + i * TARGET_LONG_BYTES,
3179                                 (int *) cache_ovly_table[i], 4);
3180         if (cache_ovly_table[i][VMA] == osect->the_bfd_section->vma &&
3181             cache_ovly_table[i][LMA] == osect->the_bfd_section->lma     /* &&
3182                                                                            cache_ovly_table[i][SIZE] == size */ )
3183           {
3184             osect->ovly_mapped = cache_ovly_table[i][MAPPED];
3185             return 1;
3186           }
3187         else                    /* Warning!  Warning!  Target's ovly table has changed! */
3188           return 0;
3189       }
3190   return 0;
3191 }
3192
3193 /* Function: simple_overlay_update
3194    If OSECT is NULL, then update all sections' mapped state
3195    (after re-reading the entire target _ovly_table).
3196    If OSECT is non-NULL, then try to find a matching entry in the
3197    cached ovly_table and update only OSECT's mapped state.
3198    If a cached entry can't be found or the cache isn't valid, then
3199    re-read the entire cache, and go ahead and update all sections.  */
3200
3201 static void
3202 simple_overlay_update (osect)
3203      struct obj_section *osect;
3204 {
3205   struct objfile *objfile;
3206
3207   /* Were we given an osect to look up?  NULL means do all of them. */
3208   if (osect)
3209     /* Have we got a cached copy of the target's overlay table? */
3210     if (cache_ovly_table != NULL)
3211       /* Does its cached location match what's currently in the symtab? */
3212       if (cache_ovly_table_base ==
3213           SYMBOL_VALUE_ADDRESS (lookup_minimal_symbol ("_ovly_table", 0, 0)))
3214         /* Then go ahead and try to look up this single section in the cache */
3215         if (simple_overlay_update_1 (osect))
3216           /* Found it!  We're done. */
3217           return;
3218
3219   /* Cached table no good: need to read the entire table anew.
3220      Or else we want all the sections, in which case it's actually
3221      more efficient to read the whole table in one block anyway.  */
3222
3223   if (simple_read_overlay_table () == 0)        /* read failed?  No table? */
3224     {
3225       warning ("Failed to read the target overlay mapping table.");
3226       return;
3227     }
3228   /* Now may as well update all sections, even if only one was requested. */
3229   ALL_OBJSECTIONS (objfile, osect)
3230     if (section_is_overlay (osect->the_bfd_section))
3231     {
3232       int i, size;
3233
3234       size = bfd_get_section_size_before_reloc (osect->the_bfd_section);
3235       for (i = 0; i < cache_novlys; i++)
3236         if (cache_ovly_table[i][VMA] == osect->the_bfd_section->vma &&
3237             cache_ovly_table[i][LMA] == osect->the_bfd_section->lma     /* &&
3238                                                                            cache_ovly_table[i][SIZE] == size */ )
3239           {                     /* obj_section matches i'th entry in ovly_table */
3240             osect->ovly_mapped = cache_ovly_table[i][MAPPED];
3241             break;              /* finished with inner for loop: break out */
3242           }
3243     }
3244 }
3245
3246
3247 void
3248 _initialize_symfile ()
3249 {
3250   struct cmd_list_element *c;
3251
3252   c = add_cmd ("symbol-file", class_files, symbol_file_command,
3253                "Load symbol table from executable file FILE.\n\
3254 The `file' command can also load symbol tables, as well as setting the file\n\
3255 to execute.", &cmdlist);
3256   c->completer = filename_completer;
3257
3258   c = add_cmd ("add-symbol-file", class_files, add_symbol_file_command,
3259                "Usage: add-symbol-file FILE ADDR [-s <SECT> <SECT_ADDR> -s <SECT> <SECT_ADDR> ...]\n\
3260 Load the symbols from FILE, assuming FILE has been dynamically loaded.\n\
3261 ADDR is the starting address of the file's text.\n\
3262 The optional arguments are section-name section-address pairs and\n\
3263 should be specified if the data and bss segments are not contiguous\n\
3264 with the text. SECT is a section name to be loaded at SECT_ADDR.",
3265                &cmdlist);
3266   c->completer = filename_completer;
3267
3268   c = add_cmd ("add-shared-symbol-files", class_files,
3269                add_shared_symbol_files_command,
3270    "Load the symbols from shared objects in the dynamic linker's link map.",
3271                &cmdlist);
3272   c = add_alias_cmd ("assf", "add-shared-symbol-files", class_files, 1,
3273                      &cmdlist);
3274
3275   c = add_cmd ("load", class_files, load_command,
3276                "Dynamically load FILE into the running program, and record its symbols\n\
3277 for access from GDB.", &cmdlist);
3278   c->completer = filename_completer;
3279
3280   add_show_from_set
3281     (add_set_cmd ("symbol-reloading", class_support, var_boolean,
3282                   (char *) &symbol_reloading,
3283             "Set dynamic symbol table reloading multiple times in one run.",
3284                   &setlist),
3285      &showlist);
3286
3287   add_prefix_cmd ("overlay", class_support, overlay_command,
3288                   "Commands for debugging overlays.", &overlaylist,
3289                   "overlay ", 0, &cmdlist);
3290
3291   add_com_alias ("ovly", "overlay", class_alias, 1);
3292   add_com_alias ("ov", "overlay", class_alias, 1);
3293
3294   add_cmd ("map-overlay", class_support, map_overlay_command,
3295            "Assert that an overlay section is mapped.", &overlaylist);
3296
3297   add_cmd ("unmap-overlay", class_support, unmap_overlay_command,
3298            "Assert that an overlay section is unmapped.", &overlaylist);
3299
3300   add_cmd ("list-overlays", class_support, list_overlays_command,
3301            "List mappings of overlay sections.", &overlaylist);
3302
3303   add_cmd ("manual", class_support, overlay_manual_command,
3304            "Enable overlay debugging.", &overlaylist);
3305   add_cmd ("off", class_support, overlay_off_command,
3306            "Disable overlay debugging.", &overlaylist);
3307   add_cmd ("auto", class_support, overlay_auto_command,
3308            "Enable automatic overlay debugging.", &overlaylist);
3309   add_cmd ("load-target", class_support, overlay_load_command,
3310            "Read the overlay mapping state from the target.", &overlaylist);
3311
3312   /* Filename extension to source language lookup table: */
3313   init_filename_language_table ();
3314   c = add_set_cmd ("extension-language", class_files, var_string_noescape,
3315                    (char *) &ext_args,
3316                    "Set mapping between filename extension and source language.\n\
3317 Usage: set extension-language .foo bar",
3318                    &setlist);
3319   c->function.cfunc = set_ext_lang_command;
3320
3321   add_info ("extensions", info_ext_lang_command,
3322             "All filename extensions associated with a source language.");
3323
3324   add_show_from_set
3325     (add_set_cmd ("download-write-size", class_obscure,
3326                   var_integer, (char *) &download_write_size,
3327                   "Set the write size used when downloading a program.\n"
3328                   "Only used when downloading a program onto a remote\n"
3329                   "target. Specify zero, or a negative value, to disable\n"
3330                   "blocked writes. The actual size of each transfer is also\n"
3331                   "limited by the size of the target packet and the memory\n"
3332                   "cache.\n",
3333                   &setlist),
3334      &showlist);
3335 }