OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [gdb/] [symfile.c] - Blame information for rev 227

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* Generic symbol file reading for the GNU debugger, GDB.
2
 
3
   Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4
   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
5
   Free Software Foundation, Inc.
6
 
7
   Contributed by Cygnus Support, using pieces from other GDB modules.
8
 
9
   This file is part of GDB.
10
 
11
   This program is free software; you can redistribute it and/or modify
12
   it under the terms of the GNU General Public License as published by
13
   the Free Software Foundation; either version 3 of the License, or
14
   (at your option) any later version.
15
 
16
   This program is distributed in the hope that it will be useful,
17
   but WITHOUT ANY WARRANTY; without even the implied warranty of
18
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19
   GNU General Public License for more details.
20
 
21
   You should have received a copy of the GNU General Public License
22
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
23
 
24
#include "defs.h"
25
#include "arch-utils.h"
26
#include "bfdlink.h"
27
#include "symtab.h"
28
#include "gdbtypes.h"
29
#include "gdbcore.h"
30
#include "frame.h"
31
#include "target.h"
32
#include "value.h"
33
#include "symfile.h"
34
#include "objfiles.h"
35
#include "source.h"
36
#include "gdbcmd.h"
37
#include "breakpoint.h"
38
#include "language.h"
39
#include "complaints.h"
40
#include "demangle.h"
41
#include "inferior.h"
42
#include "regcache.h"
43
#include "filenames.h"          /* for DOSish file names */
44
#include "gdb-stabs.h"
45
#include "gdb_obstack.h"
46
#include "completer.h"
47
#include "bcache.h"
48
#include "hashtab.h"
49
#include "readline/readline.h"
50
#include "gdb_assert.h"
51
#include "block.h"
52
#include "observer.h"
53
#include "exec.h"
54
#include "parser-defs.h"
55
#include "varobj.h"
56
#include "elf-bfd.h"
57
#include "solib.h"
58
#include "remote.h"
59
 
60
#include <sys/types.h>
61
#include <fcntl.h>
62
#include "gdb_string.h"
63
#include "gdb_stat.h"
64
#include <ctype.h>
65
#include <time.h>
66
#include <sys/time.h>
67
 
68
 
69
int (*deprecated_ui_load_progress_hook) (const char *section, unsigned long num);
70
void (*deprecated_show_load_progress) (const char *section,
71
                            unsigned long section_sent,
72
                            unsigned long section_size,
73
                            unsigned long total_sent,
74
                            unsigned long total_size);
75
void (*deprecated_pre_add_symbol_hook) (const char *);
76
void (*deprecated_post_add_symbol_hook) (void);
77
 
78
static void clear_symtab_users_cleanup (void *ignore);
79
 
80
/* Global variables owned by this file */
81
int readnow_symbol_files;       /* Read full symbols immediately */
82
 
83
/* External variables and functions referenced. */
84
 
85
extern void report_transfer_performance (unsigned long, time_t, time_t);
86
 
87
/* Functions this file defines */
88
 
89
#if 0
90
static int simple_read_overlay_region_table (void);
91
static void simple_free_overlay_region_table (void);
92
#endif
93
 
94
static void load_command (char *, int);
95
 
96
static void symbol_file_add_main_1 (char *args, int from_tty, int flags);
97
 
98
static void add_symbol_file_command (char *, int);
99
 
100
bfd *symfile_bfd_open (char *);
101
 
102
int get_section_index (struct objfile *, char *);
103
 
104
static struct sym_fns *find_sym_fns (bfd *);
105
 
106
static void decrement_reading_symtab (void *);
107
 
108
static void overlay_invalidate_all (void);
109
 
110
void list_overlays_command (char *, int);
111
 
112
void map_overlay_command (char *, int);
113
 
114
void unmap_overlay_command (char *, int);
115
 
116
static void overlay_auto_command (char *, int);
117
 
118
static void overlay_manual_command (char *, int);
119
 
120
static void overlay_off_command (char *, int);
121
 
122
static void overlay_load_command (char *, int);
123
 
124
static void overlay_command (char *, int);
125
 
126
static void simple_free_overlay_table (void);
127
 
128
static void read_target_long_array (CORE_ADDR, unsigned int *, int, int,
129
                                    enum bfd_endian);
130
 
131
static int simple_read_overlay_table (void);
132
 
133
static int simple_overlay_update_1 (struct obj_section *);
134
 
135
static void add_filename_language (char *ext, enum language lang);
136
 
137
static void info_ext_lang_command (char *args, int from_tty);
138
 
139
static void init_filename_language_table (void);
140
 
141
static void symfile_find_segment_sections (struct objfile *objfile);
142
 
143
void _initialize_symfile (void);
144
 
145
/* List of all available sym_fns.  On gdb startup, each object file reader
146
   calls add_symtab_fns() to register information on each format it is
147
   prepared to read. */
148
 
149
static struct sym_fns *symtab_fns = NULL;
150
 
151
/* Flag for whether user will be reloading symbols multiple times.
152
   Defaults to ON for VxWorks, otherwise OFF.  */
153
 
154
#ifdef SYMBOL_RELOADING_DEFAULT
155
int symbol_reloading = SYMBOL_RELOADING_DEFAULT;
156
#else
157
int symbol_reloading = 0;
158
#endif
159
static void
160
show_symbol_reloading (struct ui_file *file, int from_tty,
161
                       struct cmd_list_element *c, const char *value)
162
{
163
  fprintf_filtered (file, _("\
164
Dynamic symbol table reloading multiple times in one run is %s.\n"),
165
                    value);
166
}
167
 
168
/* If non-zero, shared library symbols will be added automatically
169
   when the inferior is created, new libraries are loaded, or when
170
   attaching to the inferior.  This is almost always what users will
171
   want to have happen; but for very large programs, the startup time
172
   will be excessive, and so if this is a problem, the user can clear
173
   this flag and then add the shared library symbols as needed.  Note
174
   that there is a potential for confusion, since if the shared
175
   library symbols are not loaded, commands like "info fun" will *not*
176
   report all the functions that are actually present. */
177
 
178
int auto_solib_add = 1;
179
 
180
/* For systems that support it, a threshold size in megabytes.  If
181
   automatically adding a new library's symbol table to those already
182
   known to the debugger would cause the total shared library symbol
183
   size to exceed this threshhold, then the shlib's symbols are not
184
   added.  The threshold is ignored if the user explicitly asks for a
185
   shlib to be added, such as when using the "sharedlibrary"
186
   command. */
187
 
188
int auto_solib_limit;
189
 
190
 
191
/* This compares two partial symbols by names, using strcmp_iw_ordered
192
   for the comparison.  */
193
 
194
static int
195
compare_psymbols (const void *s1p, const void *s2p)
196
{
197
  struct partial_symbol *const *s1 = s1p;
198
  struct partial_symbol *const *s2 = s2p;
199
 
200
  return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*s1),
201
                            SYMBOL_SEARCH_NAME (*s2));
202
}
203
 
204
void
205
sort_pst_symbols (struct partial_symtab *pst)
206
{
207
  /* Sort the global list; don't sort the static list */
208
 
209
  qsort (pst->objfile->global_psymbols.list + pst->globals_offset,
210
         pst->n_global_syms, sizeof (struct partial_symbol *),
211
         compare_psymbols);
212
}
213
 
214
/* Make a null terminated copy of the string at PTR with SIZE characters in
215
   the obstack pointed to by OBSTACKP .  Returns the address of the copy.
216
   Note that the string at PTR does not have to be null terminated, I.E. it
217
   may be part of a larger string and we are only saving a substring. */
218
 
219
char *
220
obsavestring (const char *ptr, int size, struct obstack *obstackp)
221
{
222
  char *p = (char *) obstack_alloc (obstackp, size + 1);
223
  /* Open-coded memcpy--saves function call time.  These strings are usually
224
     short.  FIXME: Is this really still true with a compiler that can
225
     inline memcpy? */
226
  {
227
    const char *p1 = ptr;
228
    char *p2 = p;
229
    const char *end = ptr + size;
230
    while (p1 != end)
231
      *p2++ = *p1++;
232
  }
233
  p[size] = 0;
234
  return p;
235
}
236
 
237
/* Concatenate strings S1, S2 and S3; return the new string.  Space is found
238
   in the obstack pointed to by OBSTACKP.  */
239
 
240
char *
241
obconcat (struct obstack *obstackp, const char *s1, const char *s2,
242
          const char *s3)
243
{
244
  int len = strlen (s1) + strlen (s2) + strlen (s3) + 1;
245
  char *val = (char *) obstack_alloc (obstackp, len);
246
  strcpy (val, s1);
247
  strcat (val, s2);
248
  strcat (val, s3);
249
  return val;
250
}
251
 
252
/* True if we are nested inside psymtab_to_symtab. */
253
 
254
int currently_reading_symtab = 0;
255
 
256
static void
257
decrement_reading_symtab (void *dummy)
258
{
259
  currently_reading_symtab--;
260
}
261
 
262
/* Get the symbol table that corresponds to a partial_symtab.
263
   This is fast after the first time you do it.  In fact, there
264
   is an even faster macro PSYMTAB_TO_SYMTAB that does the fast
265
   case inline.  */
266
 
267
struct symtab *
268
psymtab_to_symtab (struct partial_symtab *pst)
269
{
270
  /* If it's been looked up before, return it. */
271
  if (pst->symtab)
272
    return pst->symtab;
273
 
274
  /* If it has not yet been read in, read it.  */
275
  if (!pst->readin)
276
    {
277
      struct cleanup *back_to = make_cleanup (decrement_reading_symtab, NULL);
278
      currently_reading_symtab++;
279
      (*pst->read_symtab) (pst);
280
      do_cleanups (back_to);
281
    }
282
 
283
  return pst->symtab;
284
}
285
 
286
/* Remember the lowest-addressed loadable section we've seen.
287
   This function is called via bfd_map_over_sections.
288
 
289
   In case of equal vmas, the section with the largest size becomes the
290
   lowest-addressed loadable section.
291
 
292
   If the vmas and sizes are equal, the last section is considered the
293
   lowest-addressed loadable section.  */
294
 
295
void
296
find_lowest_section (bfd *abfd, asection *sect, void *obj)
297
{
298
  asection **lowest = (asection **) obj;
299
 
300
  if (0 == (bfd_get_section_flags (abfd, sect) & SEC_LOAD))
301
    return;
302
  if (!*lowest)
303
    *lowest = sect;             /* First loadable section */
304
  else if (bfd_section_vma (abfd, *lowest) > bfd_section_vma (abfd, sect))
305
    *lowest = sect;             /* A lower loadable section */
306
  else if (bfd_section_vma (abfd, *lowest) == bfd_section_vma (abfd, sect)
307
           && (bfd_section_size (abfd, (*lowest))
308
               <= bfd_section_size (abfd, sect)))
309
    *lowest = sect;
310
}
311
 
312
/* Create a new section_addr_info, with room for NUM_SECTIONS.  */
313
 
314
struct section_addr_info *
315
alloc_section_addr_info (size_t num_sections)
316
{
317
  struct section_addr_info *sap;
318
  size_t size;
319
 
320
  size = (sizeof (struct section_addr_info)
321
          +  sizeof (struct other_sections) * (num_sections - 1));
322
  sap = (struct section_addr_info *) xmalloc (size);
323
  memset (sap, 0, size);
324
  sap->num_sections = num_sections;
325
 
326
  return sap;
327
}
328
 
329
/* Build (allocate and populate) a section_addr_info struct from
330
   an existing section table. */
331
 
332
extern struct section_addr_info *
333
build_section_addr_info_from_section_table (const struct target_section *start,
334
                                            const struct target_section *end)
335
{
336
  struct section_addr_info *sap;
337
  const struct target_section *stp;
338
  int oidx;
339
 
340
  sap = alloc_section_addr_info (end - start);
341
 
342
  for (stp = start, oidx = 0; stp != end; stp++)
343
    {
344
      if (bfd_get_section_flags (stp->bfd,
345
                                 stp->the_bfd_section) & (SEC_ALLOC | SEC_LOAD)
346
          && oidx < end - start)
347
        {
348
          sap->other[oidx].addr = stp->addr;
349
          sap->other[oidx].name
350
            = xstrdup (bfd_section_name (stp->bfd, stp->the_bfd_section));
351
          sap->other[oidx].sectindex = stp->the_bfd_section->index;
352
          oidx++;
353
        }
354
    }
355
 
356
  return sap;
357
}
358
 
359
/* Create a section_addr_info from section offsets in OBJFILE.  */
360
 
361
struct section_addr_info *
362
build_section_addr_info_from_objfile (const struct objfile *objfile)
363
{
364
  struct section_addr_info *sap;
365
  int i;
366
  struct bfd_section *sec;
367
 
368
  sap = alloc_section_addr_info (objfile->num_sections);
369
  for (i = 0, sec = objfile->obfd->sections; sec != NULL; sec = sec->next)
370
    if (bfd_get_section_flags (objfile->obfd, sec) & (SEC_ALLOC | SEC_LOAD))
371
      {
372
        sap->other[i].addr = (bfd_get_section_vma (objfile->obfd, sec)
373
                              + objfile->section_offsets->offsets[i]);
374
        sap->other[i].name = xstrdup (bfd_get_section_name (objfile->obfd,
375
                                                            sec));
376
        sap->other[i].sectindex = sec->index;
377
        i++;
378
      }
379
  return sap;
380
}
381
 
382
 
383
/* Free all memory allocated by build_section_addr_info_from_section_table. */
384
 
385
extern void
386
free_section_addr_info (struct section_addr_info *sap)
387
{
388
  int idx;
389
 
390
  for (idx = 0; idx < sap->num_sections; idx++)
391
    if (sap->other[idx].name)
392
      xfree (sap->other[idx].name);
393
  xfree (sap);
394
}
395
 
396
 
397
/* Initialize OBJFILE's sect_index_* members.  */
398
static void
399
init_objfile_sect_indices (struct objfile *objfile)
400
{
401
  asection *sect;
402
  int i;
403
 
404
  sect = bfd_get_section_by_name (objfile->obfd, ".text");
405
  if (sect)
406
    objfile->sect_index_text = sect->index;
407
 
408
  sect = bfd_get_section_by_name (objfile->obfd, ".data");
409
  if (sect)
410
    objfile->sect_index_data = sect->index;
411
 
412
  sect = bfd_get_section_by_name (objfile->obfd, ".bss");
413
  if (sect)
414
    objfile->sect_index_bss = sect->index;
415
 
416
  sect = bfd_get_section_by_name (objfile->obfd, ".rodata");
417
  if (sect)
418
    objfile->sect_index_rodata = sect->index;
419
 
420
  /* This is where things get really weird...  We MUST have valid
421
     indices for the various sect_index_* members or gdb will abort.
422
     So if for example, there is no ".text" section, we have to
423
     accomodate that.  First, check for a file with the standard
424
     one or two segments.  */
425
 
426
  symfile_find_segment_sections (objfile);
427
 
428
  /* Except when explicitly adding symbol files at some address,
429
     section_offsets contains nothing but zeros, so it doesn't matter
430
     which slot in section_offsets the individual sect_index_* members
431
     index into.  So if they are all zero, it is safe to just point
432
     all the currently uninitialized indices to the first slot.  But
433
     beware: if this is the main executable, it may be relocated
434
     later, e.g. by the remote qOffsets packet, and then this will
435
     be wrong!  That's why we try segments first.  */
436
 
437
  for (i = 0; i < objfile->num_sections; i++)
438
    {
439
      if (ANOFFSET (objfile->section_offsets, i) != 0)
440
        {
441
          break;
442
        }
443
    }
444
  if (i == objfile->num_sections)
445
    {
446
      if (objfile->sect_index_text == -1)
447
        objfile->sect_index_text = 0;
448
      if (objfile->sect_index_data == -1)
449
        objfile->sect_index_data = 0;
450
      if (objfile->sect_index_bss == -1)
451
        objfile->sect_index_bss = 0;
452
      if (objfile->sect_index_rodata == -1)
453
        objfile->sect_index_rodata = 0;
454
    }
455
}
456
 
457
/* The arguments to place_section.  */
458
 
459
struct place_section_arg
460
{
461
  struct section_offsets *offsets;
462
  CORE_ADDR lowest;
463
};
464
 
465
/* Find a unique offset to use for loadable section SECT if
466
   the user did not provide an offset.  */
467
 
468
static void
469
place_section (bfd *abfd, asection *sect, void *obj)
470
{
471
  struct place_section_arg *arg = obj;
472
  CORE_ADDR *offsets = arg->offsets->offsets, start_addr;
473
  int done;
474
  ULONGEST align = ((ULONGEST) 1) << bfd_get_section_alignment (abfd, sect);
475
 
476
  /* We are only interested in allocated sections.  */
477
  if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
478
    return;
479
 
480
  /* If the user specified an offset, honor it.  */
481
  if (offsets[sect->index] != 0)
482
    return;
483
 
484
  /* Otherwise, let's try to find a place for the section.  */
485
  start_addr = (arg->lowest + align - 1) & -align;
486
 
487
  do {
488
    asection *cur_sec;
489
 
490
    done = 1;
491
 
492
    for (cur_sec = abfd->sections; cur_sec != NULL; cur_sec = cur_sec->next)
493
      {
494
        int indx = cur_sec->index;
495
        CORE_ADDR cur_offset;
496
 
497
        /* We don't need to compare against ourself.  */
498
        if (cur_sec == sect)
499
          continue;
500
 
501
        /* We can only conflict with allocated sections.  */
502
        if ((bfd_get_section_flags (abfd, cur_sec) & SEC_ALLOC) == 0)
503
          continue;
504
 
505
        /* If the section offset is 0, either the section has not been placed
506
           yet, or it was the lowest section placed (in which case LOWEST
507
           will be past its end).  */
508
        if (offsets[indx] == 0)
509
          continue;
510
 
511
        /* If this section would overlap us, then we must move up.  */
512
        if (start_addr + bfd_get_section_size (sect) > offsets[indx]
513
            && start_addr < offsets[indx] + bfd_get_section_size (cur_sec))
514
          {
515
            start_addr = offsets[indx] + bfd_get_section_size (cur_sec);
516
            start_addr = (start_addr + align - 1) & -align;
517
            done = 0;
518
            break;
519
          }
520
 
521
        /* Otherwise, we appear to be OK.  So far.  */
522
      }
523
    }
524
  while (!done);
525
 
526
  offsets[sect->index] = start_addr;
527
  arg->lowest = start_addr + bfd_get_section_size (sect);
528
}
529
 
530
/* Store struct section_addr_info as prepared (made relative and with SECTINDEX
531
   filled-in) by addr_info_make_relative into SECTION_OFFSETS of NUM_SECTIONS
532
   entries.  */
533
 
534
void
535
relative_addr_info_to_section_offsets (struct section_offsets *section_offsets,
536
                                       int num_sections,
537
                                       struct section_addr_info *addrs)
538
{
539
  int i;
540
 
541
  memset (section_offsets, 0, SIZEOF_N_SECTION_OFFSETS (num_sections));
542
 
543
  /* Now calculate offsets for section that were specified by the caller. */
544
  for (i = 0; i < addrs->num_sections && addrs->other[i].name; i++)
545
    {
546
      struct other_sections *osp;
547
 
548
      osp = &addrs->other[i];
549
      if (osp->addr == 0)
550
        continue;
551
 
552
      /* Record all sections in offsets */
553
      /* The section_offsets in the objfile are here filled in using
554
         the BFD index. */
555
      section_offsets->offsets[osp->sectindex] = osp->addr;
556
    }
557
}
558
 
559
/* Relativize absolute addresses in ADDRS into offsets based on ABFD.  Fill-in
560
   also SECTINDEXes specific to ABFD there.  This function can be used to
561
   rebase ADDRS to start referencing different BFD than before.  */
562
 
563
void
564
addr_info_make_relative (struct section_addr_info *addrs, bfd *abfd)
565
{
566
  asection *lower_sect;
567
  CORE_ADDR lower_offset;
568
  int i;
569
 
570
  /* Find lowest loadable section to be used as starting point for
571
     continguous sections.  */
572
  lower_sect = NULL;
573
  bfd_map_over_sections (abfd, find_lowest_section, &lower_sect);
574
  if (lower_sect == NULL)
575
    {
576
      warning (_("no loadable sections found in added symbol-file %s"),
577
               bfd_get_filename (abfd));
578
      lower_offset = 0;
579
    }
580
  else
581
    lower_offset = bfd_section_vma (bfd_get_filename (abfd), lower_sect);
582
 
583
  /* Calculate offsets for the loadable sections.
584
     FIXME! Sections must be in order of increasing loadable section
585
     so that contiguous sections can use the lower-offset!!!
586
 
587
     Adjust offsets if the segments are not contiguous.
588
     If the section is contiguous, its offset should be set to
589
     the offset of the highest loadable section lower than it
590
     (the loadable section directly below it in memory).
591
     this_offset = lower_offset = lower_addr - lower_orig_addr */
592
 
593
  for (i = 0; i < addrs->num_sections && addrs->other[i].name; i++)
594
    {
595
      asection *sect = bfd_get_section_by_name (abfd, addrs->other[i].name);
596
 
597
      if (sect)
598
        {
599
          /* This is the index used by BFD. */
600
          addrs->other[i].sectindex = sect->index;
601
 
602
          if (addrs->other[i].addr != 0)
603
            {
604
              addrs->other[i].addr -= bfd_section_vma (abfd, sect);
605
              lower_offset = addrs->other[i].addr;
606
            }
607
          else
608
            addrs->other[i].addr = lower_offset;
609
        }
610
      else
611
        {
612
          warning (_("section %s not found in %s"), addrs->other[i].name,
613
                   bfd_get_filename (abfd));
614
          addrs->other[i].addr = 0;
615
 
616
          /* SECTINDEX is invalid if ADDR is zero.  */
617
        }
618
    }
619
}
620
 
621
/* Parse the user's idea of an offset for dynamic linking, into our idea
622
   of how to represent it for fast symbol reading.  This is the default
623
   version of the sym_fns.sym_offsets function for symbol readers that
624
   don't need to do anything special.  It allocates a section_offsets table
625
   for the objectfile OBJFILE and stuffs ADDR into all of the offsets.  */
626
 
627
void
628
default_symfile_offsets (struct objfile *objfile,
629
                         struct section_addr_info *addrs)
630
{
631
  objfile->num_sections = bfd_count_sections (objfile->obfd);
632
  objfile->section_offsets = (struct section_offsets *)
633
    obstack_alloc (&objfile->objfile_obstack,
634
                   SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
635
  relative_addr_info_to_section_offsets (objfile->section_offsets,
636
                                         objfile->num_sections, addrs);
637
 
638
  /* For relocatable files, all loadable sections will start at zero.
639
     The zero is meaningless, so try to pick arbitrary addresses such
640
     that no loadable sections overlap.  This algorithm is quadratic,
641
     but the number of sections in a single object file is generally
642
     small.  */
643
  if ((bfd_get_file_flags (objfile->obfd) & (EXEC_P | DYNAMIC)) == 0)
644
    {
645
      struct place_section_arg arg;
646
      bfd *abfd = objfile->obfd;
647
      asection *cur_sec;
648
      CORE_ADDR lowest = 0;
649
 
650
      for (cur_sec = abfd->sections; cur_sec != NULL; cur_sec = cur_sec->next)
651
        /* We do not expect this to happen; just skip this step if the
652
           relocatable file has a section with an assigned VMA.  */
653
        if (bfd_section_vma (abfd, cur_sec) != 0)
654
          break;
655
 
656
      if (cur_sec == NULL)
657
        {
658
          CORE_ADDR *offsets = objfile->section_offsets->offsets;
659
 
660
          /* Pick non-overlapping offsets for sections the user did not
661
             place explicitly.  */
662
          arg.offsets = objfile->section_offsets;
663
          arg.lowest = 0;
664
          bfd_map_over_sections (objfile->obfd, place_section, &arg);
665
 
666
          /* Correctly filling in the section offsets is not quite
667
             enough.  Relocatable files have two properties that
668
             (most) shared objects do not:
669
 
670
             - Their debug information will contain relocations.  Some
671
             shared libraries do also, but many do not, so this can not
672
             be assumed.
673
 
674
             - If there are multiple code sections they will be loaded
675
             at different relative addresses in memory than they are
676
             in the objfile, since all sections in the file will start
677
             at address zero.
678
 
679
             Because GDB has very limited ability to map from an
680
             address in debug info to the correct code section,
681
             it relies on adding SECT_OFF_TEXT to things which might be
682
             code.  If we clear all the section offsets, and set the
683
             section VMAs instead, then symfile_relocate_debug_section
684
             will return meaningful debug information pointing at the
685
             correct sections.
686
 
687
             GDB has too many different data structures for section
688
             addresses - a bfd, objfile, and so_list all have section
689
             tables, as does exec_ops.  Some of these could probably
690
             be eliminated.  */
691
 
692
          for (cur_sec = abfd->sections; cur_sec != NULL;
693
               cur_sec = cur_sec->next)
694
            {
695
              if ((bfd_get_section_flags (abfd, cur_sec) & SEC_ALLOC) == 0)
696
                continue;
697
 
698
              bfd_set_section_vma (abfd, cur_sec, offsets[cur_sec->index]);
699
              exec_set_section_address (bfd_get_filename (abfd), cur_sec->index,
700
                                        offsets[cur_sec->index]);
701
              offsets[cur_sec->index] = 0;
702
            }
703
        }
704
    }
705
 
706
  /* Remember the bfd indexes for the .text, .data, .bss and
707
     .rodata sections. */
708
  init_objfile_sect_indices (objfile);
709
}
710
 
711
 
712
/* Divide the file into segments, which are individual relocatable units.
713
   This is the default version of the sym_fns.sym_segments function for
714
   symbol readers that do not have an explicit representation of segments.
715
   It assumes that object files do not have segments, and fully linked
716
   files have a single segment.  */
717
 
718
struct symfile_segment_data *
719
default_symfile_segments (bfd *abfd)
720
{
721
  int num_sections, i;
722
  asection *sect;
723
  struct symfile_segment_data *data;
724
  CORE_ADDR low, high;
725
 
726
  /* Relocatable files contain enough information to position each
727
     loadable section independently; they should not be relocated
728
     in segments.  */
729
  if ((bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC)) == 0)
730
    return NULL;
731
 
732
  /* Make sure there is at least one loadable section in the file.  */
733
  for (sect = abfd->sections; sect != NULL; sect = sect->next)
734
    {
735
      if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
736
        continue;
737
 
738
      break;
739
    }
740
  if (sect == NULL)
741
    return NULL;
742
 
743
  low = bfd_get_section_vma (abfd, sect);
744
  high = low + bfd_get_section_size (sect);
745
 
746
  data = XZALLOC (struct symfile_segment_data);
747
  data->num_segments = 1;
748
  data->segment_bases = XCALLOC (1, CORE_ADDR);
749
  data->segment_sizes = XCALLOC (1, CORE_ADDR);
750
 
751
  num_sections = bfd_count_sections (abfd);
752
  data->segment_info = XCALLOC (num_sections, int);
753
 
754
  for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
755
    {
756
      CORE_ADDR vma;
757
 
758
      if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
759
        continue;
760
 
761
      vma = bfd_get_section_vma (abfd, sect);
762
      if (vma < low)
763
        low = vma;
764
      if (vma + bfd_get_section_size (sect) > high)
765
        high = vma + bfd_get_section_size (sect);
766
 
767
      data->segment_info[i] = 1;
768
    }
769
 
770
  data->segment_bases[0] = low;
771
  data->segment_sizes[0] = high - low;
772
 
773
  return data;
774
}
775
 
776
/* Process a symbol file, as either the main file or as a dynamically
777
   loaded file.
778
 
779
   OBJFILE is where the symbols are to be read from.
780
 
781
   ADDRS is the list of section load addresses.  If the user has given
782
   an 'add-symbol-file' command, then this is the list of offsets and
783
   addresses he or she provided as arguments to the command; or, if
784
   we're handling a shared library, these are the actual addresses the
785
   sections are loaded at, according to the inferior's dynamic linker
786
   (as gleaned by GDB's shared library code).  We convert each address
787
   into an offset from the section VMA's as it appears in the object
788
   file, and then call the file's sym_offsets function to convert this
789
   into a format-specific offset table --- a `struct section_offsets'.
790
   If ADDRS is non-zero, OFFSETS must be zero.
791
 
792
   OFFSETS is a table of section offsets already in the right
793
   format-specific representation.  NUM_OFFSETS is the number of
794
   elements present in OFFSETS->offsets.  If OFFSETS is non-zero, we
795
   assume this is the proper table the call to sym_offsets described
796
   above would produce.  Instead of calling sym_offsets, we just dump
797
   it right into objfile->section_offsets.  (When we're re-reading
798
   symbols from an objfile, we don't have the original load address
799
   list any more; all we have is the section offset table.)  If
800
   OFFSETS is non-zero, ADDRS must be zero.
801
 
802
   ADD_FLAGS encodes verbosity level, whether this is main symbol or
803
   an extra symbol file such as dynamically loaded code, and wether
804
   breakpoint reset should be deferred.  */
805
 
806
void
807
syms_from_objfile (struct objfile *objfile,
808
                   struct section_addr_info *addrs,
809
                   struct section_offsets *offsets,
810
                   int num_offsets,
811
                   int add_flags)
812
{
813
  struct section_addr_info *local_addr = NULL;
814
  struct cleanup *old_chain;
815
  const int mainline = add_flags & SYMFILE_MAINLINE;
816
 
817
  gdb_assert (! (addrs && offsets));
818
 
819
  init_entry_point_info (objfile);
820
  objfile->sf = find_sym_fns (objfile->obfd);
821
 
822
  if (objfile->sf == NULL)
823
    return;     /* No symbols. */
824
 
825
  /* Make sure that partially constructed symbol tables will be cleaned up
826
     if an error occurs during symbol reading.  */
827
  old_chain = make_cleanup_free_objfile (objfile);
828
 
829
  /* If ADDRS and OFFSETS are both NULL, put together a dummy address
830
     list.  We now establish the convention that an addr of zero means
831
     no load address was specified. */
832
  if (! addrs && ! offsets)
833
    {
834
      local_addr
835
        = alloc_section_addr_info (bfd_count_sections (objfile->obfd));
836
      make_cleanup (xfree, local_addr);
837
      addrs = local_addr;
838
    }
839
 
840
  /* Now either addrs or offsets is non-zero.  */
841
 
842
  if (mainline)
843
    {
844
      /* We will modify the main symbol table, make sure that all its users
845
         will be cleaned up if an error occurs during symbol reading.  */
846
      make_cleanup (clear_symtab_users_cleanup, 0 /*ignore*/);
847
 
848
      /* Since no error yet, throw away the old symbol table.  */
849
 
850
      if (symfile_objfile != NULL)
851
        {
852
          free_objfile (symfile_objfile);
853
          gdb_assert (symfile_objfile == NULL);
854
        }
855
 
856
      /* Currently we keep symbols from the add-symbol-file command.
857
         If the user wants to get rid of them, they should do "symbol-file"
858
         without arguments first.  Not sure this is the best behavior
859
         (PR 2207).  */
860
 
861
      (*objfile->sf->sym_new_init) (objfile);
862
    }
863
 
864
  /* Convert addr into an offset rather than an absolute address.
865
     We find the lowest address of a loaded segment in the objfile,
866
     and assume that <addr> is where that got loaded.
867
 
868
     We no longer warn if the lowest section is not a text segment (as
869
     happens for the PA64 port.  */
870
  if (addrs && addrs->other[0].name)
871
    addr_info_make_relative (addrs, objfile->obfd);
872
 
873
  /* Initialize symbol reading routines for this objfile, allow complaints to
874
     appear for this new file, and record how verbose to be, then do the
875
     initial symbol reading for this file. */
876
 
877
  (*objfile->sf->sym_init) (objfile);
878
  clear_complaints (&symfile_complaints, 1, add_flags & SYMFILE_VERBOSE);
879
 
880
  if (addrs)
881
    (*objfile->sf->sym_offsets) (objfile, addrs);
882
  else
883
    {
884
      size_t size = SIZEOF_N_SECTION_OFFSETS (num_offsets);
885
 
886
      /* Just copy in the offset table directly as given to us.  */
887
      objfile->num_sections = num_offsets;
888
      objfile->section_offsets
889
        = ((struct section_offsets *)
890
           obstack_alloc (&objfile->objfile_obstack, size));
891
      memcpy (objfile->section_offsets, offsets, size);
892
 
893
      init_objfile_sect_indices (objfile);
894
    }
895
 
896
  (*objfile->sf->sym_read) (objfile, add_flags);
897
 
898
  /* Discard cleanups as symbol reading was successful.  */
899
 
900
  discard_cleanups (old_chain);
901
  xfree (local_addr);
902
}
903
 
904
/* Perform required actions after either reading in the initial
905
   symbols for a new objfile, or mapping in the symbols from a reusable
906
   objfile. */
907
 
908
void
909
new_symfile_objfile (struct objfile *objfile, int add_flags)
910
{
911
 
912
  /* If this is the main symbol file we have to clean up all users of the
913
     old main symbol file. Otherwise it is sufficient to fixup all the
914
     breakpoints that may have been redefined by this symbol file.  */
915
  if (add_flags & SYMFILE_MAINLINE)
916
    {
917
      /* OK, make it the "real" symbol file.  */
918
      symfile_objfile = objfile;
919
 
920
      clear_symtab_users ();
921
    }
922
  else if ((add_flags & SYMFILE_DEFER_BP_RESET) == 0)
923
    {
924
      breakpoint_re_set ();
925
    }
926
 
927
  /* We're done reading the symbol file; finish off complaints.  */
928
  clear_complaints (&symfile_complaints, 0, add_flags & SYMFILE_VERBOSE);
929
}
930
 
931
/* Process a symbol file, as either the main file or as a dynamically
932
   loaded file.
933
 
934
   ABFD is a BFD already open on the file, as from symfile_bfd_open.
935
   This BFD will be closed on error, and is always consumed by this function.
936
 
937
   ADD_FLAGS encodes verbosity, whether this is main symbol file or
938
   extra, such as dynamically loaded code, and what to do with breakpoins.
939
 
940
   ADDRS, OFFSETS, and NUM_OFFSETS are as described for
941
   syms_from_objfile, above.
942
   ADDRS is ignored when SYMFILE_MAINLINE bit is set in ADD_FLAGS.
943
 
944
   Upon success, returns a pointer to the objfile that was added.
945
   Upon failure, jumps back to command level (never returns). */
946
 
947
static struct objfile *
948
symbol_file_add_with_addrs_or_offsets (bfd *abfd,
949
                                       int add_flags,
950
                                       struct section_addr_info *addrs,
951
                                       struct section_offsets *offsets,
952
                                       int num_offsets,
953
                                       int flags)
954
{
955
  struct objfile *objfile;
956
  struct partial_symtab *psymtab;
957
  struct cleanup *my_cleanups;
958
  const char *name = bfd_get_filename (abfd);
959
  const int from_tty = add_flags & SYMFILE_VERBOSE;
960
 
961
  my_cleanups = make_cleanup_bfd_close (abfd);
962
 
963
  /* Give user a chance to burp if we'd be
964
     interactively wiping out any existing symbols.  */
965
 
966
  if ((have_full_symbols () || have_partial_symbols ())
967
      && (add_flags & SYMFILE_MAINLINE)
968
      && from_tty
969
      && !query (_("Load new symbol table from \"%s\"? "), name))
970
    error (_("Not confirmed."));
971
 
972
  objfile = allocate_objfile (abfd, flags);
973
  discard_cleanups (my_cleanups);
974
 
975
  /* We either created a new mapped symbol table, mapped an existing
976
     symbol table file which has not had initial symbol reading
977
     performed, or need to read an unmapped symbol table. */
978
  if (from_tty || info_verbose)
979
    {
980
      if (deprecated_pre_add_symbol_hook)
981
        deprecated_pre_add_symbol_hook (name);
982
      else
983
        {
984
          printf_unfiltered (_("Reading symbols from %s..."), name);
985
          wrap_here ("");
986
          gdb_flush (gdb_stdout);
987
        }
988
    }
989
  syms_from_objfile (objfile, addrs, offsets, num_offsets,
990
                     add_flags);
991
 
992
  /* We now have at least a partial symbol table.  Check to see if the
993
     user requested that all symbols be read on initial access via either
994
     the gdb startup command line or on a per symbol file basis.  Expand
995
     all partial symbol tables for this objfile if so. */
996
 
997
  if ((flags & OBJF_READNOW) || readnow_symbol_files)
998
    {
999
      if (from_tty || info_verbose)
1000
        {
1001
          printf_unfiltered (_("expanding to full symbols..."));
1002
          wrap_here ("");
1003
          gdb_flush (gdb_stdout);
1004
        }
1005
 
1006
      for (psymtab = objfile->psymtabs;
1007
           psymtab != NULL;
1008
           psymtab = psymtab->next)
1009
        {
1010
          psymtab_to_symtab (psymtab);
1011
        }
1012
    }
1013
 
1014
  if ((from_tty || info_verbose)
1015
      && !objfile_has_symbols (objfile))
1016
    {
1017
      wrap_here ("");
1018
      printf_unfiltered (_("(no debugging symbols found)..."));
1019
      wrap_here ("");
1020
    }
1021
 
1022
  if (from_tty || info_verbose)
1023
    {
1024
      if (deprecated_post_add_symbol_hook)
1025
        deprecated_post_add_symbol_hook ();
1026
      else
1027
        printf_unfiltered (_("done.\n"));
1028
    }
1029
 
1030
  /* We print some messages regardless of whether 'from_tty ||
1031
     info_verbose' is true, so make sure they go out at the right
1032
     time.  */
1033
  gdb_flush (gdb_stdout);
1034
 
1035
  do_cleanups (my_cleanups);
1036
 
1037
  if (objfile->sf == NULL)
1038
    {
1039
      observer_notify_new_objfile (objfile);
1040
      return objfile;   /* No symbols. */
1041
    }
1042
 
1043
  new_symfile_objfile (objfile, add_flags);
1044
 
1045
  observer_notify_new_objfile (objfile);
1046
 
1047
  bfd_cache_close_all ();
1048
  return (objfile);
1049
}
1050
 
1051
/* Add BFD as a separate debug file for OBJFILE.  */
1052
 
1053
void
1054
symbol_file_add_separate (bfd *bfd, int symfile_flags, struct objfile *objfile)
1055
{
1056
  struct objfile *new_objfile;
1057
  struct section_addr_info *sap;
1058
  struct cleanup *my_cleanup;
1059
 
1060
  /* Create section_addr_info.  We can't directly use offsets from OBJFILE
1061
     because sections of BFD may not match sections of OBJFILE and because
1062
     vma may have been modified by tools such as prelink.  */
1063
  sap = build_section_addr_info_from_objfile (objfile);
1064
  my_cleanup = make_cleanup_free_section_addr_info (sap);
1065
 
1066
  new_objfile = symbol_file_add_with_addrs_or_offsets
1067
    (bfd, symfile_flags,
1068
     sap, NULL, 0,
1069
     objfile->flags & (OBJF_REORDERED | OBJF_SHARED | OBJF_READNOW
1070
                       | OBJF_USERLOADED));
1071
 
1072
  do_cleanups (my_cleanup);
1073
 
1074
  add_separate_debug_objfile (new_objfile, objfile);
1075
}
1076
 
1077
/* Process the symbol file ABFD, as either the main file or as a
1078
   dynamically loaded file.
1079
 
1080
   See symbol_file_add_with_addrs_or_offsets's comments for
1081
   details.  */
1082
struct objfile *
1083
symbol_file_add_from_bfd (bfd *abfd, int add_flags,
1084
                          struct section_addr_info *addrs,
1085
                          int flags)
1086
{
1087
  return symbol_file_add_with_addrs_or_offsets (abfd, add_flags, addrs, 0, 0,
1088
                                                flags);
1089
}
1090
 
1091
 
1092
/* Process a symbol file, as either the main file or as a dynamically
1093
   loaded file.  See symbol_file_add_with_addrs_or_offsets's comments
1094
   for details.  */
1095
struct objfile *
1096
symbol_file_add (char *name, int add_flags, struct section_addr_info *addrs,
1097
                 int flags)
1098
{
1099
  return symbol_file_add_from_bfd (symfile_bfd_open (name), add_flags, addrs,
1100
                                   flags);
1101
}
1102
 
1103
 
1104
/* Call symbol_file_add() with default values and update whatever is
1105
   affected by the loading of a new main().
1106
   Used when the file is supplied in the gdb command line
1107
   and by some targets with special loading requirements.
1108
   The auxiliary function, symbol_file_add_main_1(), has the flags
1109
   argument for the switches that can only be specified in the symbol_file
1110
   command itself.  */
1111
 
1112
void
1113
symbol_file_add_main (char *args, int from_tty)
1114
{
1115
  symbol_file_add_main_1 (args, from_tty, 0);
1116
}
1117
 
1118
static void
1119
symbol_file_add_main_1 (char *args, int from_tty, int flags)
1120
{
1121
  const int add_flags = SYMFILE_MAINLINE | (from_tty ? SYMFILE_VERBOSE : 0);
1122
  symbol_file_add (args, add_flags, NULL, flags);
1123
 
1124
  /* Getting new symbols may change our opinion about
1125
     what is frameless.  */
1126
  reinit_frame_cache ();
1127
 
1128
  set_initial_language ();
1129
}
1130
 
1131
void
1132
symbol_file_clear (int from_tty)
1133
{
1134
  if ((have_full_symbols () || have_partial_symbols ())
1135
      && from_tty
1136
      && (symfile_objfile
1137
          ? !query (_("Discard symbol table from `%s'? "),
1138
                    symfile_objfile->name)
1139
          : !query (_("Discard symbol table? "))))
1140
    error (_("Not confirmed."));
1141
 
1142
  free_all_objfiles ();
1143
 
1144
  /* solib descriptors may have handles to objfiles.  Since their
1145
     storage has just been released, we'd better wipe the solib
1146
     descriptors as well.  */
1147
  no_shared_libraries (NULL, from_tty);
1148
 
1149
  gdb_assert (symfile_objfile == NULL);
1150
  if (from_tty)
1151
    printf_unfiltered (_("No symbol file now.\n"));
1152
}
1153
 
1154
static char *
1155
get_debug_link_info (struct objfile *objfile, unsigned long *crc32_out)
1156
{
1157
  asection *sect;
1158
  bfd_size_type debuglink_size;
1159
  unsigned long crc32;
1160
  char *contents;
1161
  int crc_offset;
1162
  unsigned char *p;
1163
 
1164
  sect = bfd_get_section_by_name (objfile->obfd, ".gnu_debuglink");
1165
 
1166
  if (sect == NULL)
1167
    return NULL;
1168
 
1169
  debuglink_size = bfd_section_size (objfile->obfd, sect);
1170
 
1171
  contents = xmalloc (debuglink_size);
1172
  bfd_get_section_contents (objfile->obfd, sect, contents,
1173
                            (file_ptr)0, (bfd_size_type)debuglink_size);
1174
 
1175
  /* Crc value is stored after the filename, aligned up to 4 bytes. */
1176
  crc_offset = strlen (contents) + 1;
1177
  crc_offset = (crc_offset + 3) & ~3;
1178
 
1179
  crc32 = bfd_get_32 (objfile->obfd, (bfd_byte *) (contents + crc_offset));
1180
 
1181
  *crc32_out = crc32;
1182
  return contents;
1183
}
1184
 
1185
static int
1186
separate_debug_file_exists (const char *name, unsigned long crc,
1187
                            struct objfile *parent_objfile)
1188
{
1189
  unsigned long file_crc = 0;
1190
  bfd *abfd;
1191
  gdb_byte buffer[8*1024];
1192
  int count;
1193
  struct stat parent_stat, abfd_stat;
1194
 
1195
  /* Find a separate debug info file as if symbols would be present in
1196
     PARENT_OBJFILE itself this function would not be called.  .gnu_debuglink
1197
     section can contain just the basename of PARENT_OBJFILE without any
1198
     ".debug" suffix as "/usr/lib/debug/path/to/file" is a separate tree where
1199
     the separate debug infos with the same basename can exist. */
1200
 
1201
  if (strcmp (name, parent_objfile->name) == 0)
1202
    return 0;
1203
 
1204
  abfd = bfd_open_maybe_remote (name);
1205
 
1206
  if (!abfd)
1207
    return 0;
1208
 
1209
  /* Verify symlinks were not the cause of strcmp name difference above.
1210
 
1211
     Some operating systems, e.g. Windows, do not provide a meaningful
1212
     st_ino; they always set it to zero.  (Windows does provide a
1213
     meaningful st_dev.)  Do not indicate a duplicate library in that
1214
     case.  While there is no guarantee that a system that provides
1215
     meaningful inode numbers will never set st_ino to zero, this is
1216
     merely an optimization, so we do not need to worry about false
1217
     negatives.  */
1218
 
1219
  if (bfd_stat (abfd, &abfd_stat) == 0
1220
      && bfd_stat (parent_objfile->obfd, &parent_stat) == 0
1221
      && abfd_stat.st_dev == parent_stat.st_dev
1222
      && abfd_stat.st_ino == parent_stat.st_ino
1223
      && abfd_stat.st_ino != 0)
1224
    {
1225
      bfd_close (abfd);
1226
      return 0;
1227
    }
1228
 
1229
  while ((count = bfd_bread (buffer, sizeof (buffer), abfd)) > 0)
1230
    file_crc = gnu_debuglink_crc32 (file_crc, buffer, count);
1231
 
1232
  bfd_close (abfd);
1233
 
1234
  if (crc != file_crc)
1235
    {
1236
      warning (_("the debug information found in \"%s\""
1237
                 " does not match \"%s\" (CRC mismatch).\n"),
1238
               name, parent_objfile->name);
1239
      return 0;
1240
    }
1241
 
1242
  return 1;
1243
}
1244
 
1245
char *debug_file_directory = NULL;
1246
static void
1247
show_debug_file_directory (struct ui_file *file, int from_tty,
1248
                           struct cmd_list_element *c, const char *value)
1249
{
1250
  fprintf_filtered (file, _("\
1251
The directory where separate debug symbols are searched for is \"%s\".\n"),
1252
                    value);
1253
}
1254
 
1255
#if ! defined (DEBUG_SUBDIRECTORY)
1256
#define DEBUG_SUBDIRECTORY ".debug"
1257
#endif
1258
 
1259
char *
1260
find_separate_debug_file_by_debuglink (struct objfile *objfile)
1261
{
1262
  asection *sect;
1263
  char *basename, *name_copy, *debugdir;
1264
  char *dir = NULL;
1265
  char *debugfile = NULL;
1266
  char *canon_name = NULL;
1267
  bfd_size_type debuglink_size;
1268
  unsigned long crc32;
1269
  int i;
1270
 
1271
  basename = get_debug_link_info (objfile, &crc32);
1272
 
1273
  if (basename == NULL)
1274
    /* There's no separate debug info, hence there's no way we could
1275
       load it => no warning.  */
1276
    goto cleanup_return_debugfile;
1277
 
1278
  dir = xstrdup (objfile->name);
1279
 
1280
  /* Strip off the final filename part, leaving the directory name,
1281
     followed by a slash.  Objfile names should always be absolute and
1282
     tilde-expanded, so there should always be a slash in there
1283
     somewhere.  */
1284
  for (i = strlen(dir) - 1; i >= 0; i--)
1285
    {
1286
      if (IS_DIR_SEPARATOR (dir[i]))
1287
        break;
1288
    }
1289
  gdb_assert (i >= 0 && IS_DIR_SEPARATOR (dir[i]));
1290
  dir[i+1] = '\0';
1291
 
1292
  /* Set I to max (strlen (canon_name), strlen (dir)). */
1293
  canon_name = lrealpath (dir);
1294
  i = strlen (dir);
1295
  if (canon_name && strlen (canon_name) > i)
1296
    i = strlen (canon_name);
1297
 
1298
  debugfile = xmalloc (strlen (debug_file_directory) + 1
1299
                       + i
1300
                       + strlen (DEBUG_SUBDIRECTORY)
1301
                       + strlen ("/")
1302
                       + strlen (basename)
1303
                       + 1);
1304
 
1305
  /* First try in the same directory as the original file.  */
1306
  strcpy (debugfile, dir);
1307
  strcat (debugfile, basename);
1308
 
1309
  if (separate_debug_file_exists (debugfile, crc32, objfile))
1310
    goto cleanup_return_debugfile;
1311
 
1312
  /* Then try in the subdirectory named DEBUG_SUBDIRECTORY.  */
1313
  strcpy (debugfile, dir);
1314
  strcat (debugfile, DEBUG_SUBDIRECTORY);
1315
  strcat (debugfile, "/");
1316
  strcat (debugfile, basename);
1317
 
1318
  if (separate_debug_file_exists (debugfile, crc32, objfile))
1319
    goto cleanup_return_debugfile;
1320
 
1321
  /* Then try in the global debugfile directories.
1322
 
1323
     Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
1324
     cause "/..." lookups.  */
1325
 
1326
  debugdir = debug_file_directory;
1327
  do
1328
    {
1329
      char *debugdir_end;
1330
 
1331
      while (*debugdir == DIRNAME_SEPARATOR)
1332
        debugdir++;
1333
 
1334
      debugdir_end = strchr (debugdir, DIRNAME_SEPARATOR);
1335
      if (debugdir_end == NULL)
1336
        debugdir_end = &debugdir[strlen (debugdir)];
1337
 
1338
      memcpy (debugfile, debugdir, debugdir_end - debugdir);
1339
      debugfile[debugdir_end - debugdir] = 0;
1340
      strcat (debugfile, "/");
1341
      strcat (debugfile, dir);
1342
      strcat (debugfile, basename);
1343
 
1344
      if (separate_debug_file_exists (debugfile, crc32, objfile))
1345
        goto cleanup_return_debugfile;
1346
 
1347
      /* If the file is in the sysroot, try using its base path in the
1348
         global debugfile directory.  */
1349
      if (canon_name
1350
          && strncmp (canon_name, gdb_sysroot, strlen (gdb_sysroot)) == 0
1351
          && IS_DIR_SEPARATOR (canon_name[strlen (gdb_sysroot)]))
1352
        {
1353
          memcpy (debugfile, debugdir, debugdir_end - debugdir);
1354
          debugfile[debugdir_end - debugdir] = 0;
1355
          strcat (debugfile, canon_name + strlen (gdb_sysroot));
1356
          strcat (debugfile, "/");
1357
          strcat (debugfile, basename);
1358
 
1359
          if (separate_debug_file_exists (debugfile, crc32, objfile))
1360
            goto cleanup_return_debugfile;
1361
        }
1362
 
1363
      debugdir = debugdir_end;
1364
    }
1365
  while (*debugdir != 0);
1366
 
1367
  xfree (debugfile);
1368
  debugfile = NULL;
1369
 
1370
cleanup_return_debugfile:
1371
  xfree (canon_name);
1372
  xfree (basename);
1373
  xfree (dir);
1374
  return debugfile;
1375
}
1376
 
1377
 
1378
/* This is the symbol-file command.  Read the file, analyze its
1379
   symbols, and add a struct symtab to a symtab list.  The syntax of
1380
   the command is rather bizarre:
1381
 
1382
   1. The function buildargv implements various quoting conventions
1383
   which are undocumented and have little or nothing in common with
1384
   the way things are quoted (or not quoted) elsewhere in GDB.
1385
 
1386
   2. Options are used, which are not generally used in GDB (perhaps
1387
   "set mapped on", "set readnow on" would be better)
1388
 
1389
   3. The order of options matters, which is contrary to GNU
1390
   conventions (because it is confusing and inconvenient).  */
1391
 
1392
void
1393
symbol_file_command (char *args, int from_tty)
1394
{
1395
  dont_repeat ();
1396
 
1397
  if (args == NULL)
1398
    {
1399
      symbol_file_clear (from_tty);
1400
    }
1401
  else
1402
    {
1403
      char **argv = gdb_buildargv (args);
1404
      int flags = OBJF_USERLOADED;
1405
      struct cleanup *cleanups;
1406
      char *name = NULL;
1407
 
1408
      cleanups = make_cleanup_freeargv (argv);
1409
      while (*argv != NULL)
1410
        {
1411
          if (strcmp (*argv, "-readnow") == 0)
1412
            flags |= OBJF_READNOW;
1413
          else if (**argv == '-')
1414
            error (_("unknown option `%s'"), *argv);
1415
          else
1416
            {
1417
              symbol_file_add_main_1 (*argv, from_tty, flags);
1418
              name = *argv;
1419
            }
1420
 
1421
          argv++;
1422
        }
1423
 
1424
      if (name == NULL)
1425
        error (_("no symbol file name was specified"));
1426
 
1427
      do_cleanups (cleanups);
1428
    }
1429
}
1430
 
1431
/* Set the initial language.
1432
 
1433
   FIXME: A better solution would be to record the language in the
1434
   psymtab when reading partial symbols, and then use it (if known) to
1435
   set the language.  This would be a win for formats that encode the
1436
   language in an easily discoverable place, such as DWARF.  For
1437
   stabs, we can jump through hoops looking for specially named
1438
   symbols or try to intuit the language from the specific type of
1439
   stabs we find, but we can't do that until later when we read in
1440
   full symbols.  */
1441
 
1442
void
1443
set_initial_language (void)
1444
{
1445
  struct partial_symtab *pst;
1446
  enum language lang = language_unknown;
1447
 
1448
  pst = find_main_psymtab ();
1449
  if (pst != NULL)
1450
    {
1451
      if (pst->filename != NULL)
1452
        lang = deduce_language_from_filename (pst->filename);
1453
 
1454
      if (lang == language_unknown)
1455
        {
1456
          /* Make C the default language */
1457
          lang = language_c;
1458
        }
1459
 
1460
      set_language (lang);
1461
      expected_language = current_language; /* Don't warn the user.  */
1462
    }
1463
}
1464
 
1465
/* If NAME is a remote name open the file using remote protocol, otherwise
1466
   open it normally.  */
1467
 
1468
bfd *
1469
bfd_open_maybe_remote (const char *name)
1470
{
1471
  if (remote_filename_p (name))
1472
    return remote_bfd_open (name, gnutarget);
1473
  else
1474
    return bfd_openr (name, gnutarget);
1475
}
1476
 
1477
 
1478
/* Open the file specified by NAME and hand it off to BFD for
1479
   preliminary analysis.  Return a newly initialized bfd *, which
1480
   includes a newly malloc'd` copy of NAME (tilde-expanded and made
1481
   absolute).  In case of trouble, error() is called.  */
1482
 
1483
bfd *
1484
symfile_bfd_open (char *name)
1485
{
1486
  bfd *sym_bfd;
1487
  int desc;
1488
  char *absolute_name;
1489
 
1490
  if (remote_filename_p (name))
1491
    {
1492
      name = xstrdup (name);
1493
      sym_bfd = remote_bfd_open (name, gnutarget);
1494
      if (!sym_bfd)
1495
        {
1496
          make_cleanup (xfree, name);
1497
          error (_("`%s': can't open to read symbols: %s."), name,
1498
                 bfd_errmsg (bfd_get_error ()));
1499
        }
1500
 
1501
      if (!bfd_check_format (sym_bfd, bfd_object))
1502
        {
1503
          bfd_close (sym_bfd);
1504
          make_cleanup (xfree, name);
1505
          error (_("`%s': can't read symbols: %s."), name,
1506
                 bfd_errmsg (bfd_get_error ()));
1507
        }
1508
 
1509
      return sym_bfd;
1510
    }
1511
 
1512
  name = tilde_expand (name);   /* Returns 1st new malloc'd copy.  */
1513
 
1514
  /* Look down path for it, allocate 2nd new malloc'd copy.  */
1515
  desc = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, name,
1516
                O_RDONLY | O_BINARY, &absolute_name);
1517
#if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
1518
  if (desc < 0)
1519
    {
1520
      char *exename = alloca (strlen (name) + 5);
1521
      strcat (strcpy (exename, name), ".exe");
1522
      desc = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, exename,
1523
                    O_RDONLY | O_BINARY, &absolute_name);
1524
    }
1525
#endif
1526
  if (desc < 0)
1527
    {
1528
      make_cleanup (xfree, name);
1529
      perror_with_name (name);
1530
    }
1531
 
1532
  /* Free 1st new malloc'd copy, but keep the 2nd malloc'd copy in
1533
     bfd.  It'll be freed in free_objfile(). */
1534
  xfree (name);
1535
  name = absolute_name;
1536
 
1537
  sym_bfd = bfd_fopen (name, gnutarget, FOPEN_RB, desc);
1538
  if (!sym_bfd)
1539
    {
1540
      close (desc);
1541
      make_cleanup (xfree, name);
1542
      error (_("`%s': can't open to read symbols: %s."), name,
1543
             bfd_errmsg (bfd_get_error ()));
1544
    }
1545
  bfd_set_cacheable (sym_bfd, 1);
1546
 
1547
  if (!bfd_check_format (sym_bfd, bfd_object))
1548
    {
1549
      /* FIXME: should be checking for errors from bfd_close (for one
1550
         thing, on error it does not free all the storage associated
1551
         with the bfd).  */
1552
      bfd_close (sym_bfd);      /* This also closes desc.  */
1553
      make_cleanup (xfree, name);
1554
      error (_("`%s': can't read symbols: %s."), name,
1555
             bfd_errmsg (bfd_get_error ()));
1556
    }
1557
 
1558
  /* bfd_usrdata exists for applications and libbfd must not touch it.  */
1559
  gdb_assert (bfd_usrdata (sym_bfd) == NULL);
1560
 
1561
  return sym_bfd;
1562
}
1563
 
1564
/* Return the section index for SECTION_NAME on OBJFILE.  Return -1 if
1565
   the section was not found.  */
1566
 
1567
int
1568
get_section_index (struct objfile *objfile, char *section_name)
1569
{
1570
  asection *sect = bfd_get_section_by_name (objfile->obfd, section_name);
1571
 
1572
  if (sect)
1573
    return sect->index;
1574
  else
1575
    return -1;
1576
}
1577
 
1578
/* Link SF into the global symtab_fns list.  Called on startup by the
1579
   _initialize routine in each object file format reader, to register
1580
   information about each format the the reader is prepared to
1581
   handle. */
1582
 
1583
void
1584
add_symtab_fns (struct sym_fns *sf)
1585
{
1586
  sf->next = symtab_fns;
1587
  symtab_fns = sf;
1588
}
1589
 
1590
/* Initialize OBJFILE to read symbols from its associated BFD.  It
1591
   either returns or calls error().  The result is an initialized
1592
   struct sym_fns in the objfile structure, that contains cached
1593
   information about the symbol file.  */
1594
 
1595
static struct sym_fns *
1596
find_sym_fns (bfd *abfd)
1597
{
1598
  struct sym_fns *sf;
1599
  enum bfd_flavour our_flavour = bfd_get_flavour (abfd);
1600
 
1601
  if (our_flavour == bfd_target_srec_flavour
1602
      || our_flavour == bfd_target_ihex_flavour
1603
      || our_flavour == bfd_target_tekhex_flavour)
1604
    return NULL;        /* No symbols.  */
1605
 
1606
  for (sf = symtab_fns; sf != NULL; sf = sf->next)
1607
    if (our_flavour == sf->sym_flavour)
1608
      return sf;
1609
 
1610
  error (_("I'm sorry, Dave, I can't do that.  Symbol format `%s' unknown."),
1611
         bfd_get_target (abfd));
1612
}
1613
 
1614
 
1615
/* This function runs the load command of our current target.  */
1616
 
1617
static void
1618
load_command (char *arg, int from_tty)
1619
{
1620
  /* The user might be reloading because the binary has changed.  Take
1621
     this opportunity to check.  */
1622
  reopen_exec_file ();
1623
  reread_symbols ();
1624
 
1625
  if (arg == NULL)
1626
    {
1627
      char *parg;
1628
      int count = 0;
1629
 
1630
      parg = arg = get_exec_file (1);
1631
 
1632
      /* Count how many \ " ' tab space there are in the name.  */
1633
      while ((parg = strpbrk (parg, "\\\"'\t ")))
1634
        {
1635
          parg++;
1636
          count++;
1637
        }
1638
 
1639
      if (count)
1640
        {
1641
          /* We need to quote this string so buildargv can pull it apart.  */
1642
          char *temp = xmalloc (strlen (arg) + count + 1 );
1643
          char *ptemp = temp;
1644
          char *prev;
1645
 
1646
          make_cleanup (xfree, temp);
1647
 
1648
          prev = parg = arg;
1649
          while ((parg = strpbrk (parg, "\\\"'\t ")))
1650
            {
1651
              strncpy (ptemp, prev, parg - prev);
1652
              ptemp += parg - prev;
1653
              prev = parg++;
1654
              *ptemp++ = '\\';
1655
            }
1656
          strcpy (ptemp, prev);
1657
 
1658
          arg = temp;
1659
        }
1660
    }
1661
 
1662
  target_load (arg, from_tty);
1663
 
1664
  /* After re-loading the executable, we don't really know which
1665
     overlays are mapped any more.  */
1666
  overlay_cache_invalid = 1;
1667
}
1668
 
1669
/* This version of "load" should be usable for any target.  Currently
1670
   it is just used for remote targets, not inftarg.c or core files,
1671
   on the theory that only in that case is it useful.
1672
 
1673
   Avoiding xmodem and the like seems like a win (a) because we don't have
1674
   to worry about finding it, and (b) On VMS, fork() is very slow and so
1675
   we don't want to run a subprocess.  On the other hand, I'm not sure how
1676
   performance compares.  */
1677
 
1678
static int validate_download = 0;
1679
 
1680
/* Callback service function for generic_load (bfd_map_over_sections).  */
1681
 
1682
static void
1683
add_section_size_callback (bfd *abfd, asection *asec, void *data)
1684
{
1685
  bfd_size_type *sum = data;
1686
 
1687
  *sum += bfd_get_section_size (asec);
1688
}
1689
 
1690
/* Opaque data for load_section_callback.  */
1691
struct load_section_data {
1692
  unsigned long load_offset;
1693
  struct load_progress_data *progress_data;
1694
  VEC(memory_write_request_s) *requests;
1695
};
1696
 
1697
/* Opaque data for load_progress.  */
1698
struct load_progress_data {
1699
  /* Cumulative data.  */
1700
  unsigned long write_count;
1701
  unsigned long data_count;
1702
  bfd_size_type total_size;
1703
};
1704
 
1705
/* Opaque data for load_progress for a single section.  */
1706
struct load_progress_section_data {
1707
  struct load_progress_data *cumulative;
1708
 
1709
  /* Per-section data.  */
1710
  const char *section_name;
1711
  ULONGEST section_sent;
1712
  ULONGEST section_size;
1713
  CORE_ADDR lma;
1714
  gdb_byte *buffer;
1715
};
1716
 
1717
/* Target write callback routine for progress reporting.  */
1718
 
1719
static void
1720
load_progress (ULONGEST bytes, void *untyped_arg)
1721
{
1722
  struct load_progress_section_data *args = untyped_arg;
1723
  struct load_progress_data *totals;
1724
 
1725
  if (args == NULL)
1726
    /* Writing padding data.  No easy way to get at the cumulative
1727
       stats, so just ignore this.  */
1728
    return;
1729
 
1730
  totals = args->cumulative;
1731
 
1732
  if (bytes == 0 && args->section_sent == 0)
1733
    {
1734
      /* The write is just starting.  Let the user know we've started
1735
         this section.  */
1736
      ui_out_message (uiout, 0, "Loading section %s, size %s lma %s\n",
1737
                      args->section_name, hex_string (args->section_size),
1738
                      paddress (target_gdbarch, args->lma));
1739
      return;
1740
    }
1741
 
1742
  if (validate_download)
1743
    {
1744
      /* Broken memories and broken monitors manifest themselves here
1745
         when bring new computers to life.  This doubles already slow
1746
         downloads.  */
1747
      /* NOTE: cagney/1999-10-18: A more efficient implementation
1748
         might add a verify_memory() method to the target vector and
1749
         then use that.  remote.c could implement that method using
1750
         the ``qCRC'' packet.  */
1751
      gdb_byte *check = xmalloc (bytes);
1752
      struct cleanup *verify_cleanups = make_cleanup (xfree, check);
1753
 
1754
      if (target_read_memory (args->lma, check, bytes) != 0)
1755
        error (_("Download verify read failed at %s"),
1756
               paddress (target_gdbarch, args->lma));
1757
      if (memcmp (args->buffer, check, bytes) != 0)
1758
        error (_("Download verify compare failed at %s"),
1759
               paddress (target_gdbarch, args->lma));
1760
      do_cleanups (verify_cleanups);
1761
    }
1762
  totals->data_count += bytes;
1763
  args->lma += bytes;
1764
  args->buffer += bytes;
1765
  totals->write_count += 1;
1766
  args->section_sent += bytes;
1767
  if (quit_flag
1768
      || (deprecated_ui_load_progress_hook != NULL
1769
          && deprecated_ui_load_progress_hook (args->section_name,
1770
                                               args->section_sent)))
1771
    error (_("Canceled the download"));
1772
 
1773
  if (deprecated_show_load_progress != NULL)
1774
    deprecated_show_load_progress (args->section_name,
1775
                                   args->section_sent,
1776
                                   args->section_size,
1777
                                   totals->data_count,
1778
                                   totals->total_size);
1779
}
1780
 
1781
/* Callback service function for generic_load (bfd_map_over_sections).  */
1782
 
1783
static void
1784
load_section_callback (bfd *abfd, asection *asec, void *data)
1785
{
1786
  struct memory_write_request *new_request;
1787
  struct load_section_data *args = data;
1788
  struct load_progress_section_data *section_data;
1789
  bfd_size_type size = bfd_get_section_size (asec);
1790
  gdb_byte *buffer;
1791
  const char *sect_name = bfd_get_section_name (abfd, asec);
1792
 
1793
  if ((bfd_get_section_flags (abfd, asec) & SEC_LOAD) == 0)
1794
    return;
1795
 
1796
  if (size == 0)
1797
    return;
1798
 
1799
  new_request = VEC_safe_push (memory_write_request_s,
1800
                               args->requests, NULL);
1801
  memset (new_request, 0, sizeof (struct memory_write_request));
1802
  section_data = xcalloc (1, sizeof (struct load_progress_section_data));
1803
  new_request->begin = bfd_section_lma (abfd, asec) + args->load_offset;
1804
  new_request->end = new_request->begin + size; /* FIXME Should size be in instead?  */
1805
  new_request->data = xmalloc (size);
1806
  new_request->baton = section_data;
1807
 
1808
  buffer = new_request->data;
1809
 
1810
  section_data->cumulative = args->progress_data;
1811
  section_data->section_name = sect_name;
1812
  section_data->section_size = size;
1813
  section_data->lma = new_request->begin;
1814
  section_data->buffer = buffer;
1815
 
1816
  bfd_get_section_contents (abfd, asec, buffer, 0, size);
1817
}
1818
 
1819
/* Clean up an entire memory request vector, including load
1820
   data and progress records.  */
1821
 
1822
static void
1823
clear_memory_write_data (void *arg)
1824
{
1825
  VEC(memory_write_request_s) **vec_p = arg;
1826
  VEC(memory_write_request_s) *vec = *vec_p;
1827
  int i;
1828
  struct memory_write_request *mr;
1829
 
1830
  for (i = 0; VEC_iterate (memory_write_request_s, vec, i, mr); ++i)
1831
    {
1832
      xfree (mr->data);
1833
      xfree (mr->baton);
1834
    }
1835
  VEC_free (memory_write_request_s, vec);
1836
}
1837
 
1838
void
1839
generic_load (char *args, int from_tty)
1840
{
1841
  bfd *loadfile_bfd;
1842
  struct timeval start_time, end_time;
1843
  char *filename;
1844
  struct cleanup *old_cleanups = make_cleanup (null_cleanup, 0);
1845
  struct load_section_data cbdata;
1846
  struct load_progress_data total_progress;
1847
 
1848
  CORE_ADDR entry;
1849
  char **argv;
1850
 
1851
  memset (&cbdata, 0, sizeof (cbdata));
1852
  memset (&total_progress, 0, sizeof (total_progress));
1853
  cbdata.progress_data = &total_progress;
1854
 
1855
  make_cleanup (clear_memory_write_data, &cbdata.requests);
1856
 
1857
  if (args == NULL)
1858
    error_no_arg (_("file to load"));
1859
 
1860
  argv = gdb_buildargv (args);
1861
  make_cleanup_freeargv (argv);
1862
 
1863
  filename = tilde_expand (argv[0]);
1864
  make_cleanup (xfree, filename);
1865
 
1866
  if (argv[1] != NULL)
1867
    {
1868
      char *endptr;
1869
 
1870
      cbdata.load_offset = strtoul (argv[1], &endptr, 0);
1871
 
1872
      /* If the last word was not a valid number then
1873
         treat it as a file name with spaces in.  */
1874
      if (argv[1] == endptr)
1875
        error (_("Invalid download offset:%s."), argv[1]);
1876
 
1877
      if (argv[2] != NULL)
1878
        error (_("Too many parameters."));
1879
    }
1880
 
1881
  /* Open the file for loading. */
1882
  loadfile_bfd = bfd_openr (filename, gnutarget);
1883
  if (loadfile_bfd == NULL)
1884
    {
1885
      perror_with_name (filename);
1886
      return;
1887
    }
1888
 
1889
  /* FIXME: should be checking for errors from bfd_close (for one thing,
1890
     on error it does not free all the storage associated with the
1891
     bfd).  */
1892
  make_cleanup_bfd_close (loadfile_bfd);
1893
 
1894
  if (!bfd_check_format (loadfile_bfd, bfd_object))
1895
    {
1896
      error (_("\"%s\" is not an object file: %s"), filename,
1897
             bfd_errmsg (bfd_get_error ()));
1898
    }
1899
 
1900
  bfd_map_over_sections (loadfile_bfd, add_section_size_callback,
1901
                         (void *) &total_progress.total_size);
1902
 
1903
  bfd_map_over_sections (loadfile_bfd, load_section_callback, &cbdata);
1904
 
1905
  gettimeofday (&start_time, NULL);
1906
 
1907
  if (target_write_memory_blocks (cbdata.requests, flash_discard,
1908
                                  load_progress) != 0)
1909
    error (_("Load failed"));
1910
 
1911
  gettimeofday (&end_time, NULL);
1912
 
1913
  entry = bfd_get_start_address (loadfile_bfd);
1914
  ui_out_text (uiout, "Start address ");
1915
  ui_out_field_fmt (uiout, "address", "%s", paddress (target_gdbarch, entry));
1916
  ui_out_text (uiout, ", load size ");
1917
  ui_out_field_fmt (uiout, "load-size", "%lu", total_progress.data_count);
1918
  ui_out_text (uiout, "\n");
1919
  /* We were doing this in remote-mips.c, I suspect it is right
1920
     for other targets too.  */
1921
  regcache_write_pc (get_current_regcache (), entry);
1922
 
1923
  /* Reset breakpoints, now that we have changed the load image.  For
1924
     instance, breakpoints may have been set (or reset, by
1925
     post_create_inferior) while connected to the target but before we
1926
     loaded the program.  In that case, the prologue analyzer could
1927
     have read instructions from the target to find the right
1928
     breakpoint locations.  Loading has changed the contents of that
1929
     memory.  */
1930
 
1931
  breakpoint_re_set ();
1932
 
1933
  /* FIXME: are we supposed to call symbol_file_add or not?  According
1934
     to a comment from remote-mips.c (where a call to symbol_file_add
1935
     was commented out), making the call confuses GDB if more than one
1936
     file is loaded in.  Some targets do (e.g., remote-vx.c) but
1937
     others don't (or didn't - perhaps they have all been deleted).  */
1938
 
1939
  print_transfer_performance (gdb_stdout, total_progress.data_count,
1940
                              total_progress.write_count,
1941
                              &start_time, &end_time);
1942
 
1943
  do_cleanups (old_cleanups);
1944
}
1945
 
1946
/* Report how fast the transfer went. */
1947
 
1948
/* DEPRECATED: cagney/1999-10-18: report_transfer_performance is being
1949
   replaced by print_transfer_performance (with a very different
1950
   function signature). */
1951
 
1952
void
1953
report_transfer_performance (unsigned long data_count, time_t start_time,
1954
                             time_t end_time)
1955
{
1956
  struct timeval start, end;
1957
 
1958
  start.tv_sec = start_time;
1959
  start.tv_usec = 0;
1960
  end.tv_sec = end_time;
1961
  end.tv_usec = 0;
1962
 
1963
  print_transfer_performance (gdb_stdout, data_count, 0, &start, &end);
1964
}
1965
 
1966
void
1967
print_transfer_performance (struct ui_file *stream,
1968
                            unsigned long data_count,
1969
                            unsigned long write_count,
1970
                            const struct timeval *start_time,
1971
                            const struct timeval *end_time)
1972
{
1973
  ULONGEST time_count;
1974
 
1975
  /* Compute the elapsed time in milliseconds, as a tradeoff between
1976
     accuracy and overflow.  */
1977
  time_count = (end_time->tv_sec - start_time->tv_sec) * 1000;
1978
  time_count += (end_time->tv_usec - start_time->tv_usec) / 1000;
1979
 
1980
  ui_out_text (uiout, "Transfer rate: ");
1981
  if (time_count > 0)
1982
    {
1983
      unsigned long rate = ((ULONGEST) data_count * 1000) / time_count;
1984
 
1985
      if (ui_out_is_mi_like_p (uiout))
1986
        {
1987
          ui_out_field_fmt (uiout, "transfer-rate", "%lu", rate * 8);
1988
          ui_out_text (uiout, " bits/sec");
1989
        }
1990
      else if (rate < 1024)
1991
        {
1992
          ui_out_field_fmt (uiout, "transfer-rate", "%lu", rate);
1993
          ui_out_text (uiout, " bytes/sec");
1994
        }
1995
      else
1996
        {
1997
          ui_out_field_fmt (uiout, "transfer-rate", "%lu", rate / 1024);
1998
          ui_out_text (uiout, " KB/sec");
1999
        }
2000
    }
2001
  else
2002
    {
2003
      ui_out_field_fmt (uiout, "transferred-bits", "%lu", (data_count * 8));
2004
      ui_out_text (uiout, " bits in <1 sec");
2005
    }
2006
  if (write_count > 0)
2007
    {
2008
      ui_out_text (uiout, ", ");
2009
      ui_out_field_fmt (uiout, "write-rate", "%lu", data_count / write_count);
2010
      ui_out_text (uiout, " bytes/write");
2011
    }
2012
  ui_out_text (uiout, ".\n");
2013
}
2014
 
2015
/* This function allows the addition of incrementally linked object files.
2016
   It does not modify any state in the target, only in the debugger.  */
2017
/* Note: ezannoni 2000-04-13 This function/command used to have a
2018
   special case syntax for the rombug target (Rombug is the boot
2019
   monitor for Microware's OS-9 / OS-9000, see remote-os9k.c). In the
2020
   rombug case, the user doesn't need to supply a text address,
2021
   instead a call to target_link() (in target.c) would supply the
2022
   value to use. We are now discontinuing this type of ad hoc syntax. */
2023
 
2024
static void
2025
add_symbol_file_command (char *args, int from_tty)
2026
{
2027
  struct gdbarch *gdbarch = get_current_arch ();
2028
  char *filename = NULL;
2029
  int flags = OBJF_USERLOADED;
2030
  char *arg;
2031
  int expecting_option = 0;
2032
  int section_index = 0;
2033
  int argcnt = 0;
2034
  int sec_num = 0;
2035
  int i;
2036
  int expecting_sec_name = 0;
2037
  int expecting_sec_addr = 0;
2038
  char **argv;
2039
 
2040
  struct sect_opt
2041
  {
2042
    char *name;
2043
    char *value;
2044
  };
2045
 
2046
  struct section_addr_info *section_addrs;
2047
  struct sect_opt *sect_opts = NULL;
2048
  size_t num_sect_opts = 0;
2049
  struct cleanup *my_cleanups = make_cleanup (null_cleanup, NULL);
2050
 
2051
  num_sect_opts = 16;
2052
  sect_opts = (struct sect_opt *) xmalloc (num_sect_opts
2053
                                           * sizeof (struct sect_opt));
2054
 
2055
  dont_repeat ();
2056
 
2057
  if (args == NULL)
2058
    error (_("add-symbol-file takes a file name and an address"));
2059
 
2060
  argv = gdb_buildargv (args);
2061
  make_cleanup_freeargv (argv);
2062
 
2063
  for (arg = argv[0], argcnt = 0; arg != NULL; arg = argv[++argcnt])
2064
    {
2065
      /* Process the argument. */
2066
      if (argcnt == 0)
2067
        {
2068
          /* The first argument is the file name. */
2069
          filename = tilde_expand (arg);
2070
          make_cleanup (xfree, filename);
2071
        }
2072
      else
2073
        if (argcnt == 1)
2074
          {
2075
            /* The second argument is always the text address at which
2076
               to load the program. */
2077
            sect_opts[section_index].name = ".text";
2078
            sect_opts[section_index].value = arg;
2079
            if (++section_index >= num_sect_opts)
2080
              {
2081
                num_sect_opts *= 2;
2082
                sect_opts = ((struct sect_opt *)
2083
                             xrealloc (sect_opts,
2084
                                       num_sect_opts
2085
                                       * sizeof (struct sect_opt)));
2086
              }
2087
          }
2088
        else
2089
          {
2090
            /* It's an option (starting with '-') or it's an argument
2091
               to an option */
2092
 
2093
            if (*arg == '-')
2094
              {
2095
                if (strcmp (arg, "-readnow") == 0)
2096
                  flags |= OBJF_READNOW;
2097
                else if (strcmp (arg, "-s") == 0)
2098
                  {
2099
                    expecting_sec_name = 1;
2100
                    expecting_sec_addr = 1;
2101
                  }
2102
              }
2103
            else
2104
              {
2105
                if (expecting_sec_name)
2106
                  {
2107
                    sect_opts[section_index].name = arg;
2108
                    expecting_sec_name = 0;
2109
                  }
2110
                else
2111
                  if (expecting_sec_addr)
2112
                    {
2113
                      sect_opts[section_index].value = arg;
2114
                      expecting_sec_addr = 0;
2115
                      if (++section_index >= num_sect_opts)
2116
                        {
2117
                          num_sect_opts *= 2;
2118
                          sect_opts = ((struct sect_opt *)
2119
                                       xrealloc (sect_opts,
2120
                                                 num_sect_opts
2121
                                                 * sizeof (struct sect_opt)));
2122
                        }
2123
                    }
2124
                  else
2125
                    error (_("USAGE: add-symbol-file <filename> <textaddress> [-mapped] [-readnow] [-s <secname> <addr>]*"));
2126
              }
2127
          }
2128
    }
2129
 
2130
  /* This command takes at least two arguments.  The first one is a
2131
     filename, and the second is the address where this file has been
2132
     loaded.  Abort now if this address hasn't been provided by the
2133
     user.  */
2134
  if (section_index < 1)
2135
    error (_("The address where %s has been loaded is missing"), filename);
2136
 
2137
  /* Print the prompt for the query below. And save the arguments into
2138
     a sect_addr_info structure to be passed around to other
2139
     functions.  We have to split this up into separate print
2140
     statements because hex_string returns a local static
2141
     string. */
2142
 
2143
  printf_unfiltered (_("add symbol table from file \"%s\" at\n"), filename);
2144
  section_addrs = alloc_section_addr_info (section_index);
2145
  make_cleanup (xfree, section_addrs);
2146
  for (i = 0; i < section_index; i++)
2147
    {
2148
      CORE_ADDR addr;
2149
      char *val = sect_opts[i].value;
2150
      char *sec = sect_opts[i].name;
2151
 
2152
      addr = parse_and_eval_address (val);
2153
 
2154
      /* Here we store the section offsets in the order they were
2155
         entered on the command line. */
2156
      section_addrs->other[sec_num].name = sec;
2157
      section_addrs->other[sec_num].addr = addr;
2158
      printf_unfiltered ("\t%s_addr = %s\n", sec,
2159
                         paddress (gdbarch, addr));
2160
      sec_num++;
2161
 
2162
      /* The object's sections are initialized when a
2163
         call is made to build_objfile_section_table (objfile).
2164
         This happens in reread_symbols.
2165
         At this point, we don't know what file type this is,
2166
         so we can't determine what section names are valid.  */
2167
    }
2168
 
2169
  if (from_tty && (!query ("%s", "")))
2170
    error (_("Not confirmed."));
2171
 
2172
  symbol_file_add (filename, from_tty ? SYMFILE_VERBOSE : 0,
2173
                   section_addrs, flags);
2174
 
2175
  /* Getting new symbols may change our opinion about what is
2176
     frameless.  */
2177
  reinit_frame_cache ();
2178
  do_cleanups (my_cleanups);
2179
}
2180
 
2181
 
2182
/* Re-read symbols if a symbol-file has changed.  */
2183
void
2184
reread_symbols (void)
2185
{
2186
  struct objfile *objfile;
2187
  long new_modtime;
2188
  int reread_one = 0;
2189
  struct stat new_statbuf;
2190
  int res;
2191
 
2192
  /* With the addition of shared libraries, this should be modified,
2193
     the load time should be saved in the partial symbol tables, since
2194
     different tables may come from different source files.  FIXME.
2195
     This routine should then walk down each partial symbol table
2196
     and see if the symbol table that it originates from has been changed */
2197
 
2198
  for (objfile = object_files; objfile; objfile = objfile->next)
2199
    {
2200
      /* solib-sunos.c creates one objfile with obfd.  */
2201
      if (objfile->obfd == NULL)
2202
        continue;
2203
 
2204
      /* Separate debug objfiles are handled in the main objfile.  */
2205
      if (objfile->separate_debug_objfile_backlink)
2206
        continue;
2207
 
2208
#ifdef DEPRECATED_IBM6000_TARGET
2209
      /* If this object is from a shared library, then you should
2210
         stat on the library name, not member name. */
2211
 
2212
      if (objfile->obfd->my_archive)
2213
        res = stat (objfile->obfd->my_archive->filename, &new_statbuf);
2214
      else
2215
#endif
2216
        res = stat (objfile->name, &new_statbuf);
2217
      if (res != 0)
2218
        {
2219
          /* FIXME, should use print_sys_errmsg but it's not filtered. */
2220
          printf_unfiltered (_("`%s' has disappeared; keeping its symbols.\n"),
2221
                             objfile->name);
2222
          continue;
2223
        }
2224
      new_modtime = new_statbuf.st_mtime;
2225
      if (new_modtime != objfile->mtime)
2226
        {
2227
          struct cleanup *old_cleanups;
2228
          struct section_offsets *offsets;
2229
          int num_offsets;
2230
          char *obfd_filename;
2231
 
2232
          printf_unfiltered (_("`%s' has changed; re-reading symbols.\n"),
2233
                             objfile->name);
2234
 
2235
          /* There are various functions like symbol_file_add,
2236
             symfile_bfd_open, syms_from_objfile, etc., which might
2237
             appear to do what we want.  But they have various other
2238
             effects which we *don't* want.  So we just do stuff
2239
             ourselves.  We don't worry about mapped files (for one thing,
2240
             any mapped file will be out of date).  */
2241
 
2242
          /* If we get an error, blow away this objfile (not sure if
2243
             that is the correct response for things like shared
2244
             libraries).  */
2245
          old_cleanups = make_cleanup_free_objfile (objfile);
2246
          /* We need to do this whenever any symbols go away.  */
2247
          make_cleanup (clear_symtab_users_cleanup, 0 /*ignore*/);
2248
 
2249
          if (exec_bfd != NULL && strcmp (bfd_get_filename (objfile->obfd),
2250
                                          bfd_get_filename (exec_bfd)) == 0)
2251
            {
2252
              /* Reload EXEC_BFD without asking anything.  */
2253
 
2254
              exec_file_attach (bfd_get_filename (objfile->obfd), 0);
2255
            }
2256
 
2257
          /* Clean up any state BFD has sitting around.  We don't need
2258
             to close the descriptor but BFD lacks a way of closing the
2259
             BFD without closing the descriptor.  */
2260
          obfd_filename = bfd_get_filename (objfile->obfd);
2261
          if (!bfd_close (objfile->obfd))
2262
            error (_("Can't close BFD for %s: %s"), objfile->name,
2263
                   bfd_errmsg (bfd_get_error ()));
2264
          objfile->obfd = bfd_open_maybe_remote (obfd_filename);
2265
          if (objfile->obfd == NULL)
2266
            error (_("Can't open %s to read symbols."), objfile->name);
2267
          else
2268
            objfile->obfd = gdb_bfd_ref (objfile->obfd);
2269
          /* bfd_openr sets cacheable to true, which is what we want.  */
2270
          if (!bfd_check_format (objfile->obfd, bfd_object))
2271
            error (_("Can't read symbols from %s: %s."), objfile->name,
2272
                   bfd_errmsg (bfd_get_error ()));
2273
 
2274
          /* Save the offsets, we will nuke them with the rest of the
2275
             objfile_obstack.  */
2276
          num_offsets = objfile->num_sections;
2277
          offsets = ((struct section_offsets *)
2278
                     alloca (SIZEOF_N_SECTION_OFFSETS (num_offsets)));
2279
          memcpy (offsets, objfile->section_offsets,
2280
                  SIZEOF_N_SECTION_OFFSETS (num_offsets));
2281
 
2282
          /* Remove any references to this objfile in the global
2283
             value lists.  */
2284
          preserve_values (objfile);
2285
 
2286
          /* Nuke all the state that we will re-read.  Much of the following
2287
             code which sets things to NULL really is necessary to tell
2288
             other parts of GDB that there is nothing currently there.
2289
 
2290
             Try to keep the freeing order compatible with free_objfile.  */
2291
 
2292
          if (objfile->sf != NULL)
2293
            {
2294
              (*objfile->sf->sym_finish) (objfile);
2295
            }
2296
 
2297
          clear_objfile_data (objfile);
2298
 
2299
          /* Free the separate debug objfiles.  It will be
2300
             automatically recreated by sym_read.  */
2301
          free_objfile_separate_debug (objfile);
2302
 
2303
          /* FIXME: Do we have to free a whole linked list, or is this
2304
             enough?  */
2305
          if (objfile->global_psymbols.list)
2306
            xfree (objfile->global_psymbols.list);
2307
          memset (&objfile->global_psymbols, 0,
2308
                  sizeof (objfile->global_psymbols));
2309
          if (objfile->static_psymbols.list)
2310
            xfree (objfile->static_psymbols.list);
2311
          memset (&objfile->static_psymbols, 0,
2312
                  sizeof (objfile->static_psymbols));
2313
 
2314
          /* Free the obstacks for non-reusable objfiles */
2315
          bcache_xfree (objfile->psymbol_cache);
2316
          objfile->psymbol_cache = bcache_xmalloc ();
2317
          bcache_xfree (objfile->macro_cache);
2318
          objfile->macro_cache = bcache_xmalloc ();
2319
          bcache_xfree (objfile->filename_cache);
2320
          objfile->filename_cache = bcache_xmalloc ();
2321
          if (objfile->demangled_names_hash != NULL)
2322
            {
2323
              htab_delete (objfile->demangled_names_hash);
2324
              objfile->demangled_names_hash = NULL;
2325
            }
2326
          obstack_free (&objfile->objfile_obstack, 0);
2327
          objfile->sections = NULL;
2328
          objfile->symtabs = NULL;
2329
          objfile->psymtabs = NULL;
2330
          objfile->psymtabs_addrmap = NULL;
2331
          objfile->free_psymtabs = NULL;
2332
          objfile->cp_namespace_symtab = NULL;
2333
          objfile->msymbols = NULL;
2334
          objfile->deprecated_sym_private = NULL;
2335
          objfile->minimal_symbol_count = 0;
2336
          memset (&objfile->msymbol_hash, 0,
2337
                  sizeof (objfile->msymbol_hash));
2338
          memset (&objfile->msymbol_demangled_hash, 0,
2339
                  sizeof (objfile->msymbol_demangled_hash));
2340
 
2341
          objfile->psymbol_cache = bcache_xmalloc ();
2342
          objfile->macro_cache = bcache_xmalloc ();
2343
          objfile->filename_cache = bcache_xmalloc ();
2344
          /* obstack_init also initializes the obstack so it is
2345
             empty.  We could use obstack_specify_allocation but
2346
             gdb_obstack.h specifies the alloc/dealloc
2347
             functions.  */
2348
          obstack_init (&objfile->objfile_obstack);
2349
          if (build_objfile_section_table (objfile))
2350
            {
2351
              error (_("Can't find the file sections in `%s': %s"),
2352
                     objfile->name, bfd_errmsg (bfd_get_error ()));
2353
            }
2354
          terminate_minimal_symbol_table (objfile);
2355
 
2356
          /* We use the same section offsets as from last time.  I'm not
2357
             sure whether that is always correct for shared libraries.  */
2358
          objfile->section_offsets = (struct section_offsets *)
2359
            obstack_alloc (&objfile->objfile_obstack,
2360
                           SIZEOF_N_SECTION_OFFSETS (num_offsets));
2361
          memcpy (objfile->section_offsets, offsets,
2362
                  SIZEOF_N_SECTION_OFFSETS (num_offsets));
2363
          objfile->num_sections = num_offsets;
2364
 
2365
          /* What the hell is sym_new_init for, anyway?  The concept of
2366
             distinguishing between the main file and additional files
2367
             in this way seems rather dubious.  */
2368
          if (objfile == symfile_objfile)
2369
            {
2370
              (*objfile->sf->sym_new_init) (objfile);
2371
            }
2372
 
2373
          (*objfile->sf->sym_init) (objfile);
2374
          clear_complaints (&symfile_complaints, 1, 1);
2375
          /* Do not set flags as this is safe and we don't want to be
2376
             verbose.  */
2377
          (*objfile->sf->sym_read) (objfile, 0);
2378
          if (!objfile_has_symbols (objfile))
2379
            {
2380
              wrap_here ("");
2381
              printf_unfiltered (_("(no debugging symbols found)\n"));
2382
              wrap_here ("");
2383
            }
2384
 
2385
          /* We're done reading the symbol file; finish off complaints.  */
2386
          clear_complaints (&symfile_complaints, 0, 1);
2387
 
2388
          /* Getting new symbols may change our opinion about what is
2389
             frameless.  */
2390
 
2391
          reinit_frame_cache ();
2392
 
2393
          /* Discard cleanups as symbol reading was successful.  */
2394
          discard_cleanups (old_cleanups);
2395
 
2396
          /* If the mtime has changed between the time we set new_modtime
2397
             and now, we *want* this to be out of date, so don't call stat
2398
             again now.  */
2399
          objfile->mtime = new_modtime;
2400
          reread_one = 1;
2401
          init_entry_point_info (objfile);
2402
        }
2403
    }
2404
 
2405
  if (reread_one)
2406
    {
2407
      /* Notify objfiles that we've modified objfile sections.  */
2408
      objfiles_changed ();
2409
 
2410
      clear_symtab_users ();
2411
      /* At least one objfile has changed, so we can consider that
2412
         the executable we're debugging has changed too.  */
2413
      observer_notify_executable_changed ();
2414
    }
2415
}
2416
 
2417
 
2418
 
2419
typedef struct
2420
{
2421
  char *ext;
2422
  enum language lang;
2423
}
2424
filename_language;
2425
 
2426
static filename_language *filename_language_table;
2427
static int fl_table_size, fl_table_next;
2428
 
2429
static void
2430
add_filename_language (char *ext, enum language lang)
2431
{
2432
  if (fl_table_next >= fl_table_size)
2433
    {
2434
      fl_table_size += 10;
2435
      filename_language_table =
2436
        xrealloc (filename_language_table,
2437
                  fl_table_size * sizeof (*filename_language_table));
2438
    }
2439
 
2440
  filename_language_table[fl_table_next].ext = xstrdup (ext);
2441
  filename_language_table[fl_table_next].lang = lang;
2442
  fl_table_next++;
2443
}
2444
 
2445
static char *ext_args;
2446
static void
2447
show_ext_args (struct ui_file *file, int from_tty,
2448
               struct cmd_list_element *c, const char *value)
2449
{
2450
  fprintf_filtered (file, _("\
2451
Mapping between filename extension and source language is \"%s\".\n"),
2452
                    value);
2453
}
2454
 
2455
static void
2456
set_ext_lang_command (char *args, int from_tty, struct cmd_list_element *e)
2457
{
2458
  int i;
2459
  char *cp = ext_args;
2460
  enum language lang;
2461
 
2462
  /* First arg is filename extension, starting with '.' */
2463
  if (*cp != '.')
2464
    error (_("'%s': Filename extension must begin with '.'"), ext_args);
2465
 
2466
  /* Find end of first arg.  */
2467
  while (*cp && !isspace (*cp))
2468
    cp++;
2469
 
2470
  if (*cp == '\0')
2471
    error (_("'%s': two arguments required -- filename extension and language"),
2472
           ext_args);
2473
 
2474
  /* Null-terminate first arg */
2475
  *cp++ = '\0';
2476
 
2477
  /* Find beginning of second arg, which should be a source language.  */
2478
  while (*cp && isspace (*cp))
2479
    cp++;
2480
 
2481
  if (*cp == '\0')
2482
    error (_("'%s': two arguments required -- filename extension and language"),
2483
           ext_args);
2484
 
2485
  /* Lookup the language from among those we know.  */
2486
  lang = language_enum (cp);
2487
 
2488
  /* Now lookup the filename extension: do we already know it?  */
2489
  for (i = 0; i < fl_table_next; i++)
2490
    if (0 == strcmp (ext_args, filename_language_table[i].ext))
2491
      break;
2492
 
2493
  if (i >= fl_table_next)
2494
    {
2495
      /* new file extension */
2496
      add_filename_language (ext_args, lang);
2497
    }
2498
  else
2499
    {
2500
      /* redefining a previously known filename extension */
2501
 
2502
      /* if (from_tty) */
2503
      /*   query ("Really make files of type %s '%s'?", */
2504
      /*          ext_args, language_str (lang));           */
2505
 
2506
      xfree (filename_language_table[i].ext);
2507
      filename_language_table[i].ext = xstrdup (ext_args);
2508
      filename_language_table[i].lang = lang;
2509
    }
2510
}
2511
 
2512
static void
2513
info_ext_lang_command (char *args, int from_tty)
2514
{
2515
  int i;
2516
 
2517
  printf_filtered (_("Filename extensions and the languages they represent:"));
2518
  printf_filtered ("\n\n");
2519
  for (i = 0; i < fl_table_next; i++)
2520
    printf_filtered ("\t%s\t- %s\n",
2521
                     filename_language_table[i].ext,
2522
                     language_str (filename_language_table[i].lang));
2523
}
2524
 
2525
static void
2526
init_filename_language_table (void)
2527
{
2528
  if (fl_table_size == 0)        /* protect against repetition */
2529
    {
2530
      fl_table_size = 20;
2531
      fl_table_next = 0;
2532
      filename_language_table =
2533
        xmalloc (fl_table_size * sizeof (*filename_language_table));
2534
      add_filename_language (".c", language_c);
2535
      add_filename_language (".C", language_cplus);
2536
      add_filename_language (".cc", language_cplus);
2537
      add_filename_language (".cp", language_cplus);
2538
      add_filename_language (".cpp", language_cplus);
2539
      add_filename_language (".cxx", language_cplus);
2540
      add_filename_language (".c++", language_cplus);
2541
      add_filename_language (".java", language_java);
2542
      add_filename_language (".class", language_java);
2543
      add_filename_language (".m", language_objc);
2544
      add_filename_language (".f", language_fortran);
2545
      add_filename_language (".F", language_fortran);
2546
      add_filename_language (".s", language_asm);
2547
      add_filename_language (".sx", language_asm);
2548
      add_filename_language (".S", language_asm);
2549
      add_filename_language (".pas", language_pascal);
2550
      add_filename_language (".p", language_pascal);
2551
      add_filename_language (".pp", language_pascal);
2552
      add_filename_language (".adb", language_ada);
2553
      add_filename_language (".ads", language_ada);
2554
      add_filename_language (".a", language_ada);
2555
      add_filename_language (".ada", language_ada);
2556
    }
2557
}
2558
 
2559
enum language
2560
deduce_language_from_filename (char *filename)
2561
{
2562
  int i;
2563
  char *cp;
2564
 
2565
  if (filename != NULL)
2566
    if ((cp = strrchr (filename, '.')) != NULL)
2567
      for (i = 0; i < fl_table_next; i++)
2568
        if (strcmp (cp, filename_language_table[i].ext) == 0)
2569
          return filename_language_table[i].lang;
2570
 
2571
  return language_unknown;
2572
}
2573
 
2574
/* allocate_symtab:
2575
 
2576
   Allocate and partly initialize a new symbol table.  Return a pointer
2577
   to it.  error() if no space.
2578
 
2579
   Caller must set these fields:
2580
   LINETABLE(symtab)
2581
   symtab->blockvector
2582
   symtab->dirname
2583
   symtab->free_code
2584
   symtab->free_ptr
2585
 */
2586
 
2587
struct symtab *
2588
allocate_symtab (char *filename, struct objfile *objfile)
2589
{
2590
  struct symtab *symtab;
2591
 
2592
  symtab = (struct symtab *)
2593
    obstack_alloc (&objfile->objfile_obstack, sizeof (struct symtab));
2594
  memset (symtab, 0, sizeof (*symtab));
2595
  symtab->filename = (char *) bcache (filename, strlen (filename) + 1,
2596
                                      objfile->filename_cache);
2597
  symtab->fullname = NULL;
2598
  symtab->language = deduce_language_from_filename (filename);
2599
  symtab->debugformat = "unknown";
2600
 
2601
  /* Hook it to the objfile it comes from */
2602
 
2603
  symtab->objfile = objfile;
2604
  symtab->next = objfile->symtabs;
2605
  objfile->symtabs = symtab;
2606
 
2607
  return (symtab);
2608
}
2609
 
2610
struct partial_symtab *
2611
allocate_psymtab (const char *filename, struct objfile *objfile)
2612
{
2613
  struct partial_symtab *psymtab;
2614
 
2615
  if (objfile->free_psymtabs)
2616
    {
2617
      psymtab = objfile->free_psymtabs;
2618
      objfile->free_psymtabs = psymtab->next;
2619
    }
2620
  else
2621
    psymtab = (struct partial_symtab *)
2622
      obstack_alloc (&objfile->objfile_obstack,
2623
                     sizeof (struct partial_symtab));
2624
 
2625
  memset (psymtab, 0, sizeof (struct partial_symtab));
2626
  psymtab->filename = (char *) bcache (filename, strlen (filename) + 1,
2627
                                       objfile->filename_cache);
2628
  psymtab->symtab = NULL;
2629
 
2630
  /* Prepend it to the psymtab list for the objfile it belongs to.
2631
     Psymtabs are searched in most recent inserted -> least recent
2632
     inserted order. */
2633
 
2634
  psymtab->objfile = objfile;
2635
  psymtab->next = objfile->psymtabs;
2636
  objfile->psymtabs = psymtab;
2637
#if 0
2638
  {
2639
    struct partial_symtab **prev_pst;
2640
    psymtab->objfile = objfile;
2641
    psymtab->next = NULL;
2642
    prev_pst = &(objfile->psymtabs);
2643
    while ((*prev_pst) != NULL)
2644
      prev_pst = &((*prev_pst)->next);
2645
    (*prev_pst) = psymtab;
2646
  }
2647
#endif
2648
 
2649
  return (psymtab);
2650
}
2651
 
2652
void
2653
discard_psymtab (struct partial_symtab *pst)
2654
{
2655
  struct partial_symtab **prev_pst;
2656
 
2657
  /* From dbxread.c:
2658
     Empty psymtabs happen as a result of header files which don't
2659
     have any symbols in them.  There can be a lot of them.  But this
2660
     check is wrong, in that a psymtab with N_SLINE entries but
2661
     nothing else is not empty, but we don't realize that.  Fixing
2662
     that without slowing things down might be tricky.  */
2663
 
2664
  /* First, snip it out of the psymtab chain */
2665
 
2666
  prev_pst = &(pst->objfile->psymtabs);
2667
  while ((*prev_pst) != pst)
2668
    prev_pst = &((*prev_pst)->next);
2669
  (*prev_pst) = pst->next;
2670
 
2671
  /* Next, put it on a free list for recycling */
2672
 
2673
  pst->next = pst->objfile->free_psymtabs;
2674
  pst->objfile->free_psymtabs = pst;
2675
}
2676
 
2677
 
2678
/* Reset all data structures in gdb which may contain references to symbol
2679
   table data.  */
2680
 
2681
void
2682
clear_symtab_users (void)
2683
{
2684
  /* Someday, we should do better than this, by only blowing away
2685
     the things that really need to be blown.  */
2686
 
2687
  /* Clear the "current" symtab first, because it is no longer valid.
2688
     breakpoint_re_set may try to access the current symtab.  */
2689
  clear_current_source_symtab_and_line ();
2690
 
2691
  clear_displays ();
2692
  breakpoint_re_set ();
2693
  set_default_breakpoint (0, NULL, 0, 0, 0);
2694
  clear_pc_function_cache ();
2695
  observer_notify_new_objfile (NULL);
2696
 
2697
  /* Clear globals which might have pointed into a removed objfile.
2698
     FIXME: It's not clear which of these are supposed to persist
2699
     between expressions and which ought to be reset each time.  */
2700
  expression_context_block = NULL;
2701
  innermost_block = NULL;
2702
 
2703
  /* Varobj may refer to old symbols, perform a cleanup.  */
2704
  varobj_invalidate ();
2705
 
2706
}
2707
 
2708
static void
2709
clear_symtab_users_cleanup (void *ignore)
2710
{
2711
  clear_symtab_users ();
2712
}
2713
 
2714
/* Allocate and partially fill a partial symtab.  It will be
2715
   completely filled at the end of the symbol list.
2716
 
2717
   FILENAME is the name of the symbol-file we are reading from. */
2718
 
2719
struct partial_symtab *
2720
start_psymtab_common (struct objfile *objfile,
2721
                      struct section_offsets *section_offsets,
2722
                      const char *filename,
2723
                      CORE_ADDR textlow, struct partial_symbol **global_syms,
2724
                      struct partial_symbol **static_syms)
2725
{
2726
  struct partial_symtab *psymtab;
2727
 
2728
  psymtab = allocate_psymtab (filename, objfile);
2729
  psymtab->section_offsets = section_offsets;
2730
  psymtab->textlow = textlow;
2731
  psymtab->texthigh = psymtab->textlow;         /* default */
2732
  psymtab->globals_offset = global_syms - objfile->global_psymbols.list;
2733
  psymtab->statics_offset = static_syms - objfile->static_psymbols.list;
2734
  return (psymtab);
2735
}
2736
 
2737
/* Helper function, initialises partial symbol structure and stashes
2738
   it into objfile's bcache.  Note that our caching mechanism will
2739
   use all fields of struct partial_symbol to determine hash value of the
2740
   structure.  In other words, having two symbols with the same name but
2741
   different domain (or address) is possible and correct.  */
2742
 
2743
static const struct partial_symbol *
2744
add_psymbol_to_bcache (char *name, int namelength, int copy_name,
2745
                       domain_enum domain,
2746
                       enum address_class class,
2747
                       long val,        /* Value as a long */
2748
                       CORE_ADDR coreaddr,      /* Value as a CORE_ADDR */
2749
                       enum language language, struct objfile *objfile,
2750
                       int *added)
2751
{
2752
  /* psymbol is static so that there will be no uninitialized gaps in the
2753
     structure which might contain random data, causing cache misses in
2754
     bcache. */
2755
  static struct partial_symbol psymbol;
2756
 
2757
  /* However, we must ensure that the entire 'value' field has been
2758
     zeroed before assigning to it, because an assignment may not
2759
     write the entire field.  */
2760
  memset (&psymbol.ginfo.value, 0, sizeof (psymbol.ginfo.value));
2761
  /* val and coreaddr are mutually exclusive, one of them *will* be zero */
2762
  if (val != 0)
2763
    {
2764
      SYMBOL_VALUE (&psymbol) = val;
2765
    }
2766
  else
2767
    {
2768
      SYMBOL_VALUE_ADDRESS (&psymbol) = coreaddr;
2769
    }
2770
  SYMBOL_SECTION (&psymbol) = 0;
2771
  SYMBOL_LANGUAGE (&psymbol) = language;
2772
  PSYMBOL_DOMAIN (&psymbol) = domain;
2773
  PSYMBOL_CLASS (&psymbol) = class;
2774
 
2775
  SYMBOL_SET_NAMES (&psymbol, name, namelength, copy_name, objfile);
2776
 
2777
  /* Stash the partial symbol away in the cache */
2778
  return bcache_full (&psymbol, sizeof (struct partial_symbol),
2779
                      objfile->psymbol_cache, added);
2780
}
2781
 
2782
/* Helper function, adds partial symbol to the given partial symbol
2783
   list.  */
2784
 
2785
static void
2786
append_psymbol_to_list (struct psymbol_allocation_list *list,
2787
                        const struct partial_symbol *psym,
2788
                        struct objfile *objfile)
2789
{
2790
  if (list->next >= list->list + list->size)
2791
    extend_psymbol_list (list, objfile);
2792
  *list->next++ = (struct partial_symbol *) psym;
2793
  OBJSTAT (objfile, n_psyms++);
2794
}
2795
 
2796
/* Add a symbol with a long value to a psymtab.
2797
   Since one arg is a struct, we pass in a ptr and deref it (sigh).
2798
   Return the partial symbol that has been added.  */
2799
 
2800
/* NOTE: carlton/2003-09-11: The reason why we return the partial
2801
   symbol is so that callers can get access to the symbol's demangled
2802
   name, which they don't have any cheap way to determine otherwise.
2803
   (Currenly, dwarf2read.c is the only file who uses that information,
2804
   though it's possible that other readers might in the future.)
2805
   Elena wasn't thrilled about that, and I don't blame her, but we
2806
   couldn't come up with a better way to get that information.  If
2807
   it's needed in other situations, we could consider breaking up
2808
   SYMBOL_SET_NAMES to provide access to the demangled name lookup
2809
   cache.  */
2810
 
2811
const struct partial_symbol *
2812
add_psymbol_to_list (char *name, int namelength, int copy_name,
2813
                     domain_enum domain,
2814
                     enum address_class class,
2815
                     struct psymbol_allocation_list *list,
2816
                     long val,  /* Value as a long */
2817
                     CORE_ADDR coreaddr,        /* Value as a CORE_ADDR */
2818
                     enum language language, struct objfile *objfile)
2819
{
2820
  const struct partial_symbol *psym;
2821
 
2822
  int added;
2823
 
2824
  /* Stash the partial symbol away in the cache */
2825
  psym = add_psymbol_to_bcache (name, namelength, copy_name, domain, class,
2826
                                val, coreaddr, language, objfile, &added);
2827
 
2828
  /* Do not duplicate global partial symbols.  */
2829
  if (list == &objfile->global_psymbols
2830
      && !added)
2831
    return psym;
2832
 
2833
  /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
2834
  append_psymbol_to_list (list, psym, objfile);
2835
  return psym;
2836
}
2837
 
2838
/* Initialize storage for partial symbols.  */
2839
 
2840
void
2841
init_psymbol_list (struct objfile *objfile, int total_symbols)
2842
{
2843
  /* Free any previously allocated psymbol lists.  */
2844
 
2845
  if (objfile->global_psymbols.list)
2846
    {
2847
      xfree (objfile->global_psymbols.list);
2848
    }
2849
  if (objfile->static_psymbols.list)
2850
    {
2851
      xfree (objfile->static_psymbols.list);
2852
    }
2853
 
2854
  /* Current best guess is that approximately a twentieth
2855
     of the total symbols (in a debugging file) are global or static
2856
     oriented symbols */
2857
 
2858
  objfile->global_psymbols.size = total_symbols / 10;
2859
  objfile->static_psymbols.size = total_symbols / 10;
2860
 
2861
  if (objfile->global_psymbols.size > 0)
2862
    {
2863
      objfile->global_psymbols.next =
2864
        objfile->global_psymbols.list = (struct partial_symbol **)
2865
        xmalloc ((objfile->global_psymbols.size
2866
                  * sizeof (struct partial_symbol *)));
2867
    }
2868
  if (objfile->static_psymbols.size > 0)
2869
    {
2870
      objfile->static_psymbols.next =
2871
        objfile->static_psymbols.list = (struct partial_symbol **)
2872
        xmalloc ((objfile->static_psymbols.size
2873
                  * sizeof (struct partial_symbol *)));
2874
    }
2875
}
2876
 
2877
/* OVERLAYS:
2878
   The following code implements an abstraction for debugging overlay sections.
2879
 
2880
   The target model is as follows:
2881
   1) The gnu linker will permit multiple sections to be mapped into the
2882
   same VMA, each with its own unique LMA (or load address).
2883
   2) It is assumed that some runtime mechanism exists for mapping the
2884
   sections, one by one, from the load address into the VMA address.
2885
   3) This code provides a mechanism for gdb to keep track of which
2886
   sections should be considered to be mapped from the VMA to the LMA.
2887
   This information is used for symbol lookup, and memory read/write.
2888
   For instance, if a section has been mapped then its contents
2889
   should be read from the VMA, otherwise from the LMA.
2890
 
2891
   Two levels of debugger support for overlays are available.  One is
2892
   "manual", in which the debugger relies on the user to tell it which
2893
   overlays are currently mapped.  This level of support is
2894
   implemented entirely in the core debugger, and the information about
2895
   whether a section is mapped is kept in the objfile->obj_section table.
2896
 
2897
   The second level of support is "automatic", and is only available if
2898
   the target-specific code provides functionality to read the target's
2899
   overlay mapping table, and translate its contents for the debugger
2900
   (by updating the mapped state information in the obj_section tables).
2901
 
2902
   The interface is as follows:
2903
   User commands:
2904
   overlay map <name>   -- tell gdb to consider this section mapped
2905
   overlay unmap <name> -- tell gdb to consider this section unmapped
2906
   overlay list         -- list the sections that GDB thinks are mapped
2907
   overlay read-target  -- get the target's state of what's mapped
2908
   overlay off/manual/auto -- set overlay debugging state
2909
   Functional interface:
2910
   find_pc_mapped_section(pc):    if the pc is in the range of a mapped
2911
   section, return that section.
2912
   find_pc_overlay(pc):       find any overlay section that contains
2913
   the pc, either in its VMA or its LMA
2914
   section_is_mapped(sect):       true if overlay is marked as mapped
2915
   section_is_overlay(sect):      true if section's VMA != LMA
2916
   pc_in_mapped_range(pc,sec):    true if pc belongs to section's VMA
2917
   pc_in_unmapped_range(...):     true if pc belongs to section's LMA
2918
   sections_overlap(sec1, sec2):  true if mapped sec1 and sec2 ranges overlap
2919
   overlay_mapped_address(...):   map an address from section's LMA to VMA
2920
   overlay_unmapped_address(...): map an address from section's VMA to LMA
2921
   symbol_overlayed_address(...): Return a "current" address for symbol:
2922
   either in VMA or LMA depending on whether
2923
   the symbol's section is currently mapped
2924
 */
2925
 
2926
/* Overlay debugging state: */
2927
 
2928
enum overlay_debugging_state overlay_debugging = ovly_off;
2929
int overlay_cache_invalid = 0;   /* True if need to refresh mapped state */
2930
 
2931
/* Function: section_is_overlay (SECTION)
2932
   Returns true if SECTION has VMA not equal to LMA, ie.
2933
   SECTION is loaded at an address different from where it will "run".  */
2934
 
2935
int
2936
section_is_overlay (struct obj_section *section)
2937
{
2938
  if (overlay_debugging && section)
2939
    {
2940
      bfd *abfd = section->objfile->obfd;
2941
      asection *bfd_section = section->the_bfd_section;
2942
 
2943
      if (bfd_section_lma (abfd, bfd_section) != 0
2944
          && bfd_section_lma (abfd, bfd_section)
2945
             != bfd_section_vma (abfd, bfd_section))
2946
        return 1;
2947
    }
2948
 
2949
  return 0;
2950
}
2951
 
2952
/* Function: overlay_invalidate_all (void)
2953
   Invalidate the mapped state of all overlay sections (mark it as stale).  */
2954
 
2955
static void
2956
overlay_invalidate_all (void)
2957
{
2958
  struct objfile *objfile;
2959
  struct obj_section *sect;
2960
 
2961
  ALL_OBJSECTIONS (objfile, sect)
2962
    if (section_is_overlay (sect))
2963
      sect->ovly_mapped = -1;
2964
}
2965
 
2966
/* Function: section_is_mapped (SECTION)
2967
   Returns true if section is an overlay, and is currently mapped.
2968
 
2969
   Access to the ovly_mapped flag is restricted to this function, so
2970
   that we can do automatic update.  If the global flag
2971
   OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
2972
   overlay_invalidate_all.  If the mapped state of the particular
2973
   section is stale, then call TARGET_OVERLAY_UPDATE to refresh it.  */
2974
 
2975
int
2976
section_is_mapped (struct obj_section *osect)
2977
{
2978
  struct gdbarch *gdbarch;
2979
 
2980
  if (osect == 0 || !section_is_overlay (osect))
2981
    return 0;
2982
 
2983
  switch (overlay_debugging)
2984
    {
2985
    default:
2986
    case ovly_off:
2987
      return 0;                  /* overlay debugging off */
2988
    case ovly_auto:             /* overlay debugging automatic */
2989
      /* Unles there is a gdbarch_overlay_update function,
2990
         there's really nothing useful to do here (can't really go auto)  */
2991
      gdbarch = get_objfile_arch (osect->objfile);
2992
      if (gdbarch_overlay_update_p (gdbarch))
2993
        {
2994
          if (overlay_cache_invalid)
2995
            {
2996
              overlay_invalidate_all ();
2997
              overlay_cache_invalid = 0;
2998
            }
2999
          if (osect->ovly_mapped == -1)
3000
            gdbarch_overlay_update (gdbarch, osect);
3001
        }
3002
      /* fall thru to manual case */
3003
    case ovly_on:               /* overlay debugging manual */
3004
      return osect->ovly_mapped == 1;
3005
    }
3006
}
3007
 
3008
/* Function: pc_in_unmapped_range
3009
   If PC falls into the lma range of SECTION, return true, else false.  */
3010
 
3011
CORE_ADDR
3012
pc_in_unmapped_range (CORE_ADDR pc, struct obj_section *section)
3013
{
3014
  if (section_is_overlay (section))
3015
    {
3016
      bfd *abfd = section->objfile->obfd;
3017
      asection *bfd_section = section->the_bfd_section;
3018
 
3019
      /* We assume the LMA is relocated by the same offset as the VMA.  */
3020
      bfd_vma size = bfd_get_section_size (bfd_section);
3021
      CORE_ADDR offset = obj_section_offset (section);
3022
 
3023
      if (bfd_get_section_lma (abfd, bfd_section) + offset <= pc
3024
          && pc < bfd_get_section_lma (abfd, bfd_section) + offset + size)
3025
        return 1;
3026
    }
3027
 
3028
  return 0;
3029
}
3030
 
3031
/* Function: pc_in_mapped_range
3032
   If PC falls into the vma range of SECTION, return true, else false.  */
3033
 
3034
CORE_ADDR
3035
pc_in_mapped_range (CORE_ADDR pc, struct obj_section *section)
3036
{
3037
  if (section_is_overlay (section))
3038
    {
3039
      if (obj_section_addr (section) <= pc
3040
          && pc < obj_section_endaddr (section))
3041
        return 1;
3042
    }
3043
 
3044
  return 0;
3045
}
3046
 
3047
 
3048
/* Return true if the mapped ranges of sections A and B overlap, false
3049
   otherwise.  */
3050
static int
3051
sections_overlap (struct obj_section *a, struct obj_section *b)
3052
{
3053
  CORE_ADDR a_start = obj_section_addr (a);
3054
  CORE_ADDR a_end = obj_section_endaddr (a);
3055
  CORE_ADDR b_start = obj_section_addr (b);
3056
  CORE_ADDR b_end = obj_section_endaddr (b);
3057
 
3058
  return (a_start < b_end && b_start < a_end);
3059
}
3060
 
3061
/* Function: overlay_unmapped_address (PC, SECTION)
3062
   Returns the address corresponding to PC in the unmapped (load) range.
3063
   May be the same as PC.  */
3064
 
3065
CORE_ADDR
3066
overlay_unmapped_address (CORE_ADDR pc, struct obj_section *section)
3067
{
3068
  if (section_is_overlay (section) && pc_in_mapped_range (pc, section))
3069
    {
3070
      bfd *abfd = section->objfile->obfd;
3071
      asection *bfd_section = section->the_bfd_section;
3072
 
3073
      return pc + bfd_section_lma (abfd, bfd_section)
3074
                - bfd_section_vma (abfd, bfd_section);
3075
    }
3076
 
3077
  return pc;
3078
}
3079
 
3080
/* Function: overlay_mapped_address (PC, SECTION)
3081
   Returns the address corresponding to PC in the mapped (runtime) range.
3082
   May be the same as PC.  */
3083
 
3084
CORE_ADDR
3085
overlay_mapped_address (CORE_ADDR pc, struct obj_section *section)
3086
{
3087
  if (section_is_overlay (section) && pc_in_unmapped_range (pc, section))
3088
    {
3089
      bfd *abfd = section->objfile->obfd;
3090
      asection *bfd_section = section->the_bfd_section;
3091
 
3092
      return pc + bfd_section_vma (abfd, bfd_section)
3093
                - bfd_section_lma (abfd, bfd_section);
3094
    }
3095
 
3096
  return pc;
3097
}
3098
 
3099
 
3100
/* Function: symbol_overlayed_address
3101
   Return one of two addresses (relative to the VMA or to the LMA),
3102
   depending on whether the section is mapped or not.  */
3103
 
3104
CORE_ADDR
3105
symbol_overlayed_address (CORE_ADDR address, struct obj_section *section)
3106
{
3107
  if (overlay_debugging)
3108
    {
3109
      /* If the symbol has no section, just return its regular address. */
3110
      if (section == 0)
3111
        return address;
3112
      /* If the symbol's section is not an overlay, just return its address */
3113
      if (!section_is_overlay (section))
3114
        return address;
3115
      /* If the symbol's section is mapped, just return its address */
3116
      if (section_is_mapped (section))
3117
        return address;
3118
      /*
3119
       * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
3120
       * then return its LOADED address rather than its vma address!!
3121
       */
3122
      return overlay_unmapped_address (address, section);
3123
    }
3124
  return address;
3125
}
3126
 
3127
/* Function: find_pc_overlay (PC)
3128
   Return the best-match overlay section for PC:
3129
   If PC matches a mapped overlay section's VMA, return that section.
3130
   Else if PC matches an unmapped section's VMA, return that section.
3131
   Else if PC matches an unmapped section's LMA, return that section.  */
3132
 
3133
struct obj_section *
3134
find_pc_overlay (CORE_ADDR pc)
3135
{
3136
  struct objfile *objfile;
3137
  struct obj_section *osect, *best_match = NULL;
3138
 
3139
  if (overlay_debugging)
3140
    ALL_OBJSECTIONS (objfile, osect)
3141
      if (section_is_overlay (osect))
3142
      {
3143
        if (pc_in_mapped_range (pc, osect))
3144
          {
3145
            if (section_is_mapped (osect))
3146
              return osect;
3147
            else
3148
              best_match = osect;
3149
          }
3150
        else if (pc_in_unmapped_range (pc, osect))
3151
          best_match = osect;
3152
      }
3153
  return best_match;
3154
}
3155
 
3156
/* Function: find_pc_mapped_section (PC)
3157
   If PC falls into the VMA address range of an overlay section that is
3158
   currently marked as MAPPED, return that section.  Else return NULL.  */
3159
 
3160
struct obj_section *
3161
find_pc_mapped_section (CORE_ADDR pc)
3162
{
3163
  struct objfile *objfile;
3164
  struct obj_section *osect;
3165
 
3166
  if (overlay_debugging)
3167
    ALL_OBJSECTIONS (objfile, osect)
3168
      if (pc_in_mapped_range (pc, osect) && section_is_mapped (osect))
3169
        return osect;
3170
 
3171
  return NULL;
3172
}
3173
 
3174
/* Function: list_overlays_command
3175
   Print a list of mapped sections and their PC ranges */
3176
 
3177
void
3178
list_overlays_command (char *args, int from_tty)
3179
{
3180
  int nmapped = 0;
3181
  struct objfile *objfile;
3182
  struct obj_section *osect;
3183
 
3184
  if (overlay_debugging)
3185
    ALL_OBJSECTIONS (objfile, osect)
3186
      if (section_is_mapped (osect))
3187
      {
3188
        struct gdbarch *gdbarch = get_objfile_arch (objfile);
3189
        const char *name;
3190
        bfd_vma lma, vma;
3191
        int size;
3192
 
3193
        vma = bfd_section_vma (objfile->obfd, osect->the_bfd_section);
3194
        lma = bfd_section_lma (objfile->obfd, osect->the_bfd_section);
3195
        size = bfd_get_section_size (osect->the_bfd_section);
3196
        name = bfd_section_name (objfile->obfd, osect->the_bfd_section);
3197
 
3198
        printf_filtered ("Section %s, loaded at ", name);
3199
        fputs_filtered (paddress (gdbarch, lma), gdb_stdout);
3200
        puts_filtered (" - ");
3201
        fputs_filtered (paddress (gdbarch, lma + size), gdb_stdout);
3202
        printf_filtered (", mapped at ");
3203
        fputs_filtered (paddress (gdbarch, vma), gdb_stdout);
3204
        puts_filtered (" - ");
3205
        fputs_filtered (paddress (gdbarch, vma + size), gdb_stdout);
3206
        puts_filtered ("\n");
3207
 
3208
        nmapped++;
3209
      }
3210
  if (nmapped == 0)
3211
    printf_filtered (_("No sections are mapped.\n"));
3212
}
3213
 
3214
/* Function: map_overlay_command
3215
   Mark the named section as mapped (ie. residing at its VMA address).  */
3216
 
3217
void
3218
map_overlay_command (char *args, int from_tty)
3219
{
3220
  struct objfile *objfile, *objfile2;
3221
  struct obj_section *sec, *sec2;
3222
 
3223
  if (!overlay_debugging)
3224
    error (_("\
3225
Overlay debugging not enabled.  Use either the 'overlay auto' or\n\
3226
the 'overlay manual' command."));
3227
 
3228
  if (args == 0 || *args == 0)
3229
    error (_("Argument required: name of an overlay section"));
3230
 
3231
  /* First, find a section matching the user supplied argument */
3232
  ALL_OBJSECTIONS (objfile, sec)
3233
    if (!strcmp (bfd_section_name (objfile->obfd, sec->the_bfd_section), args))
3234
    {
3235
      /* Now, check to see if the section is an overlay. */
3236
      if (!section_is_overlay (sec))
3237
        continue;               /* not an overlay section */
3238
 
3239
      /* Mark the overlay as "mapped" */
3240
      sec->ovly_mapped = 1;
3241
 
3242
      /* Next, make a pass and unmap any sections that are
3243
         overlapped by this new section: */
3244
      ALL_OBJSECTIONS (objfile2, sec2)
3245
        if (sec2->ovly_mapped && sec != sec2 && sections_overlap (sec, sec2))
3246
        {
3247
          if (info_verbose)
3248
            printf_unfiltered (_("Note: section %s unmapped by overlap\n"),
3249
                             bfd_section_name (objfile->obfd,
3250
                                               sec2->the_bfd_section));
3251
          sec2->ovly_mapped = 0; /* sec2 overlaps sec: unmap sec2 */
3252
        }
3253
      return;
3254
    }
3255
  error (_("No overlay section called %s"), args);
3256
}
3257
 
3258
/* Function: unmap_overlay_command
3259
   Mark the overlay section as unmapped
3260
   (ie. resident in its LMA address range, rather than the VMA range).  */
3261
 
3262
void
3263
unmap_overlay_command (char *args, int from_tty)
3264
{
3265
  struct objfile *objfile;
3266
  struct obj_section *sec;
3267
 
3268
  if (!overlay_debugging)
3269
    error (_("\
3270
Overlay debugging not enabled.  Use either the 'overlay auto' or\n\
3271
the 'overlay manual' command."));
3272
 
3273
  if (args == 0 || *args == 0)
3274
    error (_("Argument required: name of an overlay section"));
3275
 
3276
  /* First, find a section matching the user supplied argument */
3277
  ALL_OBJSECTIONS (objfile, sec)
3278
    if (!strcmp (bfd_section_name (objfile->obfd, sec->the_bfd_section), args))
3279
    {
3280
      if (!sec->ovly_mapped)
3281
        error (_("Section %s is not mapped"), args);
3282
      sec->ovly_mapped = 0;
3283
      return;
3284
    }
3285
  error (_("No overlay section called %s"), args);
3286
}
3287
 
3288
/* Function: overlay_auto_command
3289
   A utility command to turn on overlay debugging.
3290
   Possibly this should be done via a set/show command. */
3291
 
3292
static void
3293
overlay_auto_command (char *args, int from_tty)
3294
{
3295
  overlay_debugging = ovly_auto;
3296
  enable_overlay_breakpoints ();
3297
  if (info_verbose)
3298
    printf_unfiltered (_("Automatic overlay debugging enabled."));
3299
}
3300
 
3301
/* Function: overlay_manual_command
3302
   A utility command to turn on overlay debugging.
3303
   Possibly this should be done via a set/show command. */
3304
 
3305
static void
3306
overlay_manual_command (char *args, int from_tty)
3307
{
3308
  overlay_debugging = ovly_on;
3309
  disable_overlay_breakpoints ();
3310
  if (info_verbose)
3311
    printf_unfiltered (_("Overlay debugging enabled."));
3312
}
3313
 
3314
/* Function: overlay_off_command
3315
   A utility command to turn on overlay debugging.
3316
   Possibly this should be done via a set/show command. */
3317
 
3318
static void
3319
overlay_off_command (char *args, int from_tty)
3320
{
3321
  overlay_debugging = ovly_off;
3322
  disable_overlay_breakpoints ();
3323
  if (info_verbose)
3324
    printf_unfiltered (_("Overlay debugging disabled."));
3325
}
3326
 
3327
static void
3328
overlay_load_command (char *args, int from_tty)
3329
{
3330
  struct gdbarch *gdbarch = get_current_arch ();
3331
 
3332
  if (gdbarch_overlay_update_p (gdbarch))
3333
    gdbarch_overlay_update (gdbarch, NULL);
3334
  else
3335
    error (_("This target does not know how to read its overlay state."));
3336
}
3337
 
3338
/* Function: overlay_command
3339
   A place-holder for a mis-typed command */
3340
 
3341
/* Command list chain containing all defined "overlay" subcommands. */
3342
struct cmd_list_element *overlaylist;
3343
 
3344
static void
3345
overlay_command (char *args, int from_tty)
3346
{
3347
  printf_unfiltered
3348
    ("\"overlay\" must be followed by the name of an overlay command.\n");
3349
  help_list (overlaylist, "overlay ", -1, gdb_stdout);
3350
}
3351
 
3352
 
3353
/* Target Overlays for the "Simplest" overlay manager:
3354
 
3355
   This is GDB's default target overlay layer.  It works with the
3356
   minimal overlay manager supplied as an example by Cygnus.  The
3357
   entry point is via a function pointer "gdbarch_overlay_update",
3358
   so targets that use a different runtime overlay manager can
3359
   substitute their own overlay_update function and take over the
3360
   function pointer.
3361
 
3362
   The overlay_update function pokes around in the target's data structures
3363
   to see what overlays are mapped, and updates GDB's overlay mapping with
3364
   this information.
3365
 
3366
   In this simple implementation, the target data structures are as follows:
3367
   unsigned _novlys;            /# number of overlay sections #/
3368
   unsigned _ovly_table[_novlys][4] = {
3369
   {VMA, SIZE, LMA, MAPPED},    /# one entry per overlay section #/
3370
   {..., ...,  ..., ...},
3371
   }
3372
   unsigned _novly_regions;     /# number of overlay regions #/
3373
   unsigned _ovly_region_table[_novly_regions][3] = {
3374
   {VMA, SIZE, MAPPED_TO_LMA},  /# one entry per overlay region #/
3375
   {..., ...,  ...},
3376
   }
3377
   These functions will attempt to update GDB's mappedness state in the
3378
   symbol section table, based on the target's mappedness state.
3379
 
3380
   To do this, we keep a cached copy of the target's _ovly_table, and
3381
   attempt to detect when the cached copy is invalidated.  The main
3382
   entry point is "simple_overlay_update(SECT), which looks up SECT in
3383
   the cached table and re-reads only the entry for that section from
3384
   the target (whenever possible).
3385
 */
3386
 
3387
/* Cached, dynamically allocated copies of the target data structures: */
3388
static unsigned (*cache_ovly_table)[4] = 0;
3389
#if 0
3390
static unsigned (*cache_ovly_region_table)[3] = 0;
3391
#endif
3392
static unsigned cache_novlys = 0;
3393
#if 0
3394
static unsigned cache_novly_regions = 0;
3395
#endif
3396
static CORE_ADDR cache_ovly_table_base = 0;
3397
#if 0
3398
static CORE_ADDR cache_ovly_region_table_base = 0;
3399
#endif
3400
enum ovly_index
3401
  {
3402
    VMA, SIZE, LMA, MAPPED
3403
  };
3404
 
3405
/* Throw away the cached copy of _ovly_table */
3406
static void
3407
simple_free_overlay_table (void)
3408
{
3409
  if (cache_ovly_table)
3410
    xfree (cache_ovly_table);
3411
  cache_novlys = 0;
3412
  cache_ovly_table = NULL;
3413
  cache_ovly_table_base = 0;
3414
}
3415
 
3416
#if 0
3417
/* Throw away the cached copy of _ovly_region_table */
3418
static void
3419
simple_free_overlay_region_table (void)
3420
{
3421
  if (cache_ovly_region_table)
3422
    xfree (cache_ovly_region_table);
3423
  cache_novly_regions = 0;
3424
  cache_ovly_region_table = NULL;
3425
  cache_ovly_region_table_base = 0;
3426
}
3427
#endif
3428
 
3429
/* Read an array of ints of size SIZE from the target into a local buffer.
3430
   Convert to host order.  int LEN is number of ints  */
3431
static void
3432
read_target_long_array (CORE_ADDR memaddr, unsigned int *myaddr,
3433
                        int len, int size, enum bfd_endian byte_order)
3434
{
3435
  /* FIXME (alloca): Not safe if array is very large. */
3436
  gdb_byte *buf = alloca (len * size);
3437
  int i;
3438
 
3439
  read_memory (memaddr, buf, len * size);
3440
  for (i = 0; i < len; i++)
3441
    myaddr[i] = extract_unsigned_integer (size * i + buf, size, byte_order);
3442
}
3443
 
3444
/* Find and grab a copy of the target _ovly_table
3445
   (and _novlys, which is needed for the table's size) */
3446
static int
3447
simple_read_overlay_table (void)
3448
{
3449
  struct minimal_symbol *novlys_msym, *ovly_table_msym;
3450
  struct gdbarch *gdbarch;
3451
  int word_size;
3452
  enum bfd_endian byte_order;
3453
 
3454
  simple_free_overlay_table ();
3455
  novlys_msym = lookup_minimal_symbol ("_novlys", NULL, NULL);
3456
  if (! novlys_msym)
3457
    {
3458
      error (_("Error reading inferior's overlay table: "
3459
             "couldn't find `_novlys' variable\n"
3460
             "in inferior.  Use `overlay manual' mode."));
3461
      return 0;
3462
    }
3463
 
3464
  ovly_table_msym = lookup_minimal_symbol ("_ovly_table", NULL, NULL);
3465
  if (! ovly_table_msym)
3466
    {
3467
      error (_("Error reading inferior's overlay table: couldn't find "
3468
             "`_ovly_table' array\n"
3469
             "in inferior.  Use `overlay manual' mode."));
3470
      return 0;
3471
    }
3472
 
3473
  gdbarch = get_objfile_arch (msymbol_objfile (ovly_table_msym));
3474
  word_size = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
3475
  byte_order = gdbarch_byte_order (gdbarch);
3476
 
3477
  cache_novlys = read_memory_integer (SYMBOL_VALUE_ADDRESS (novlys_msym),
3478
                                      4, byte_order);
3479
  cache_ovly_table
3480
    = (void *) xmalloc (cache_novlys * sizeof (*cache_ovly_table));
3481
  cache_ovly_table_base = SYMBOL_VALUE_ADDRESS (ovly_table_msym);
3482
  read_target_long_array (cache_ovly_table_base,
3483
                          (unsigned int *) cache_ovly_table,
3484
                          cache_novlys * 4, word_size, byte_order);
3485
 
3486
  return 1;                     /* SUCCESS */
3487
}
3488
 
3489
#if 0
3490
/* Find and grab a copy of the target _ovly_region_table
3491
   (and _novly_regions, which is needed for the table's size) */
3492
static int
3493
simple_read_overlay_region_table (void)
3494
{
3495
  struct minimal_symbol *msym;
3496
  struct gdbarch *gdbarch;
3497
  int word_size;
3498
  enum bfd_endian byte_order;
3499
 
3500
  simple_free_overlay_region_table ();
3501
  msym = lookup_minimal_symbol ("_novly_regions", NULL, NULL);
3502
  if (msym == NULL)
3503
    return 0;                    /* failure */
3504
 
3505
  gdbarch = get_objfile_arch (msymbol_objfile (msym));
3506
  word_size = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
3507
  byte_order = gdbarch_byte_order (gdbarch);
3508
 
3509
  cache_novly_regions = read_memory_integer (SYMBOL_VALUE_ADDRESS (msym),
3510
                                             4, byte_order);
3511
 
3512
  cache_ovly_region_table = (void *) xmalloc (cache_novly_regions * 12);
3513
  if (cache_ovly_region_table != NULL)
3514
    {
3515
      msym = lookup_minimal_symbol ("_ovly_region_table", NULL, NULL);
3516
      if (msym != NULL)
3517
        {
3518
          cache_ovly_region_table_base = SYMBOL_VALUE_ADDRESS (msym);
3519
          read_target_long_array (cache_ovly_region_table_base,
3520
                                  (unsigned int *) cache_ovly_region_table,
3521
                                  cache_novly_regions * 3,
3522
                                  word_size, byte_order);
3523
        }
3524
      else
3525
        return 0;                /* failure */
3526
    }
3527
  else
3528
    return 0;                    /* failure */
3529
  return 1;                     /* SUCCESS */
3530
}
3531
#endif
3532
 
3533
/* Function: simple_overlay_update_1
3534
   A helper function for simple_overlay_update.  Assuming a cached copy
3535
   of _ovly_table exists, look through it to find an entry whose vma,
3536
   lma and size match those of OSECT.  Re-read the entry and make sure
3537
   it still matches OSECT (else the table may no longer be valid).
3538
   Set OSECT's mapped state to match the entry.  Return: 1 for
3539
   success, 0 for failure.  */
3540
 
3541
static int
3542
simple_overlay_update_1 (struct obj_section *osect)
3543
{
3544
  int i, size;
3545
  bfd *obfd = osect->objfile->obfd;
3546
  asection *bsect = osect->the_bfd_section;
3547
  struct gdbarch *gdbarch = get_objfile_arch (osect->objfile);
3548
  int word_size = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
3549
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
3550
 
3551
  size = bfd_get_section_size (osect->the_bfd_section);
3552
  for (i = 0; i < cache_novlys; i++)
3553
    if (cache_ovly_table[i][VMA] == bfd_section_vma (obfd, bsect)
3554
        && cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect)
3555
        /* && cache_ovly_table[i][SIZE] == size */ )
3556
      {
3557
        read_target_long_array (cache_ovly_table_base + i * word_size,
3558
                                (unsigned int *) cache_ovly_table[i],
3559
                                4, word_size, byte_order);
3560
        if (cache_ovly_table[i][VMA] == bfd_section_vma (obfd, bsect)
3561
            && cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect)
3562
            /* && cache_ovly_table[i][SIZE] == size */ )
3563
          {
3564
            osect->ovly_mapped = cache_ovly_table[i][MAPPED];
3565
            return 1;
3566
          }
3567
        else    /* Warning!  Warning!  Target's ovly table has changed! */
3568
          return 0;
3569
      }
3570
  return 0;
3571
}
3572
 
3573
/* Function: simple_overlay_update
3574
   If OSECT is NULL, then update all sections' mapped state
3575
   (after re-reading the entire target _ovly_table).
3576
   If OSECT is non-NULL, then try to find a matching entry in the
3577
   cached ovly_table and update only OSECT's mapped state.
3578
   If a cached entry can't be found or the cache isn't valid, then
3579
   re-read the entire cache, and go ahead and update all sections.  */
3580
 
3581
void
3582
simple_overlay_update (struct obj_section *osect)
3583
{
3584
  struct objfile *objfile;
3585
 
3586
  /* Were we given an osect to look up?  NULL means do all of them. */
3587
  if (osect)
3588
    /* Have we got a cached copy of the target's overlay table? */
3589
    if (cache_ovly_table != NULL)
3590
      /* Does its cached location match what's currently in the symtab? */
3591
      if (cache_ovly_table_base ==
3592
          SYMBOL_VALUE_ADDRESS (lookup_minimal_symbol ("_ovly_table", NULL, NULL)))
3593
        /* Then go ahead and try to look up this single section in the cache */
3594
        if (simple_overlay_update_1 (osect))
3595
          /* Found it!  We're done. */
3596
          return;
3597
 
3598
  /* Cached table no good: need to read the entire table anew.
3599
     Or else we want all the sections, in which case it's actually
3600
     more efficient to read the whole table in one block anyway.  */
3601
 
3602
  if (! simple_read_overlay_table ())
3603
    return;
3604
 
3605
  /* Now may as well update all sections, even if only one was requested. */
3606
  ALL_OBJSECTIONS (objfile, osect)
3607
    if (section_is_overlay (osect))
3608
    {
3609
      int i, size;
3610
      bfd *obfd = osect->objfile->obfd;
3611
      asection *bsect = osect->the_bfd_section;
3612
 
3613
      size = bfd_get_section_size (bsect);
3614
      for (i = 0; i < cache_novlys; i++)
3615
        if (cache_ovly_table[i][VMA] == bfd_section_vma (obfd, bsect)
3616
            && cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect)
3617
            /* && cache_ovly_table[i][SIZE] == size */ )
3618
          { /* obj_section matches i'th entry in ovly_table */
3619
            osect->ovly_mapped = cache_ovly_table[i][MAPPED];
3620
            break;              /* finished with inner for loop: break out */
3621
          }
3622
    }
3623
}
3624
 
3625
/* Set the output sections and output offsets for section SECTP in
3626
   ABFD.  The relocation code in BFD will read these offsets, so we
3627
   need to be sure they're initialized.  We map each section to itself,
3628
   with no offset; this means that SECTP->vma will be honored.  */
3629
 
3630
static void
3631
symfile_dummy_outputs (bfd *abfd, asection *sectp, void *dummy)
3632
{
3633
  sectp->output_section = sectp;
3634
  sectp->output_offset = 0;
3635
}
3636
 
3637
/* Default implementation for sym_relocate.  */
3638
 
3639
 
3640
bfd_byte *
3641
default_symfile_relocate (struct objfile *objfile, asection *sectp,
3642
                          bfd_byte *buf)
3643
{
3644
  bfd *abfd = objfile->obfd;
3645
 
3646
  /* We're only interested in sections with relocation
3647
     information.  */
3648
  if ((sectp->flags & SEC_RELOC) == 0)
3649
    return NULL;
3650
 
3651
  /* We will handle section offsets properly elsewhere, so relocate as if
3652
     all sections begin at 0.  */
3653
  bfd_map_over_sections (abfd, symfile_dummy_outputs, NULL);
3654
 
3655
  return bfd_simple_get_relocated_section_contents (abfd, sectp, buf, NULL);
3656
}
3657
 
3658
/* Relocate the contents of a debug section SECTP in ABFD.  The
3659
   contents are stored in BUF if it is non-NULL, or returned in a
3660
   malloc'd buffer otherwise.
3661
 
3662
   For some platforms and debug info formats, shared libraries contain
3663
   relocations against the debug sections (particularly for DWARF-2;
3664
   one affected platform is PowerPC GNU/Linux, although it depends on
3665
   the version of the linker in use).  Also, ELF object files naturally
3666
   have unresolved relocations for their debug sections.  We need to apply
3667
   the relocations in order to get the locations of symbols correct.
3668
   Another example that may require relocation processing, is the
3669
   DWARF-2 .eh_frame section in .o files, although it isn't strictly a
3670
   debug section.  */
3671
 
3672
bfd_byte *
3673
symfile_relocate_debug_section (struct objfile *objfile,
3674
                                asection *sectp, bfd_byte *buf)
3675
{
3676
  gdb_assert (objfile->sf->sym_relocate);
3677
 
3678
  return (*objfile->sf->sym_relocate) (objfile, sectp, buf);
3679
}
3680
 
3681
struct symfile_segment_data *
3682
get_symfile_segment_data (bfd *abfd)
3683
{
3684
  struct sym_fns *sf = find_sym_fns (abfd);
3685
 
3686
  if (sf == NULL)
3687
    return NULL;
3688
 
3689
  return sf->sym_segments (abfd);
3690
}
3691
 
3692
void
3693
free_symfile_segment_data (struct symfile_segment_data *data)
3694
{
3695
  xfree (data->segment_bases);
3696
  xfree (data->segment_sizes);
3697
  xfree (data->segment_info);
3698
  xfree (data);
3699
}
3700
 
3701
 
3702
/* Given:
3703
   - DATA, containing segment addresses from the object file ABFD, and
3704
     the mapping from ABFD's sections onto the segments that own them,
3705
     and
3706
   - SEGMENT_BASES[0 .. NUM_SEGMENT_BASES - 1], holding the actual
3707
     segment addresses reported by the target,
3708
   store the appropriate offsets for each section in OFFSETS.
3709
 
3710
   If there are fewer entries in SEGMENT_BASES than there are segments
3711
   in DATA, then apply SEGMENT_BASES' last entry to all the segments.
3712
 
3713
   If there are more entries, then ignore the extra.  The target may
3714
   not be able to distinguish between an empty data segment and a
3715
   missing data segment; a missing text segment is less plausible.  */
3716
int
3717
symfile_map_offsets_to_segments (bfd *abfd, struct symfile_segment_data *data,
3718
                                 struct section_offsets *offsets,
3719
                                 int num_segment_bases,
3720
                                 const CORE_ADDR *segment_bases)
3721
{
3722
  int i;
3723
  asection *sect;
3724
 
3725
  /* It doesn't make sense to call this function unless you have some
3726
     segment base addresses.  */
3727
  gdb_assert (num_segment_bases > 0);
3728
 
3729
  /* If we do not have segment mappings for the object file, we
3730
     can not relocate it by segments.  */
3731
  gdb_assert (data != NULL);
3732
  gdb_assert (data->num_segments > 0);
3733
 
3734
  for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
3735
    {
3736
      int which = data->segment_info[i];
3737
 
3738
      gdb_assert (0 <= which && which <= data->num_segments);
3739
 
3740
      /* Don't bother computing offsets for sections that aren't
3741
         loaded as part of any segment.  */
3742
      if (! which)
3743
        continue;
3744
 
3745
      /* Use the last SEGMENT_BASES entry as the address of any extra
3746
         segments mentioned in DATA->segment_info.  */
3747
      if (which > num_segment_bases)
3748
        which = num_segment_bases;
3749
 
3750
      offsets->offsets[i] = (segment_bases[which - 1]
3751
                             - data->segment_bases[which - 1]);
3752
    }
3753
 
3754
  return 1;
3755
}
3756
 
3757
static void
3758
symfile_find_segment_sections (struct objfile *objfile)
3759
{
3760
  bfd *abfd = objfile->obfd;
3761
  int i;
3762
  asection *sect;
3763
  struct symfile_segment_data *data;
3764
 
3765
  data = get_symfile_segment_data (objfile->obfd);
3766
  if (data == NULL)
3767
    return;
3768
 
3769
  if (data->num_segments != 1 && data->num_segments != 2)
3770
    {
3771
      free_symfile_segment_data (data);
3772
      return;
3773
    }
3774
 
3775
  for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
3776
    {
3777
      CORE_ADDR vma;
3778
      int which = data->segment_info[i];
3779
 
3780
      if (which == 1)
3781
        {
3782
          if (objfile->sect_index_text == -1)
3783
            objfile->sect_index_text = sect->index;
3784
 
3785
          if (objfile->sect_index_rodata == -1)
3786
            objfile->sect_index_rodata = sect->index;
3787
        }
3788
      else if (which == 2)
3789
        {
3790
          if (objfile->sect_index_data == -1)
3791
            objfile->sect_index_data = sect->index;
3792
 
3793
          if (objfile->sect_index_bss == -1)
3794
            objfile->sect_index_bss = sect->index;
3795
        }
3796
    }
3797
 
3798
  free_symfile_segment_data (data);
3799
}
3800
 
3801
void
3802
_initialize_symfile (void)
3803
{
3804
  struct cmd_list_element *c;
3805
 
3806
  c = add_cmd ("symbol-file", class_files, symbol_file_command, _("\
3807
Load symbol table from executable file FILE.\n\
3808
The `file' command can also load symbol tables, as well as setting the file\n\
3809
to execute."), &cmdlist);
3810
  set_cmd_completer (c, filename_completer);
3811
 
3812
  c = add_cmd ("add-symbol-file", class_files, add_symbol_file_command, _("\
3813
Load symbols from FILE, assuming FILE has been dynamically loaded.\n\
3814
Usage: add-symbol-file FILE ADDR [-s <SECT> <SECT_ADDR> -s <SECT> <SECT_ADDR> ...]\n\
3815
ADDR is the starting address of the file's text.\n\
3816
The optional arguments are section-name section-address pairs and\n\
3817
should be specified if the data and bss segments are not contiguous\n\
3818
with the text.  SECT is a section name to be loaded at SECT_ADDR."),
3819
               &cmdlist);
3820
  set_cmd_completer (c, filename_completer);
3821
 
3822
  c = add_cmd ("load", class_files, load_command, _("\
3823
Dynamically load FILE into the running program, and record its symbols\n\
3824
for access from GDB.\n\
3825
A load OFFSET may also be given."), &cmdlist);
3826
  set_cmd_completer (c, filename_completer);
3827
 
3828
  add_setshow_boolean_cmd ("symbol-reloading", class_support,
3829
                           &symbol_reloading, _("\
3830
Set dynamic symbol table reloading multiple times in one run."), _("\
3831
Show dynamic symbol table reloading multiple times in one run."), NULL,
3832
                           NULL,
3833
                           show_symbol_reloading,
3834
                           &setlist, &showlist);
3835
 
3836
  add_prefix_cmd ("overlay", class_support, overlay_command,
3837
                  _("Commands for debugging overlays."), &overlaylist,
3838
                  "overlay ", 0, &cmdlist);
3839
 
3840
  add_com_alias ("ovly", "overlay", class_alias, 1);
3841
  add_com_alias ("ov", "overlay", class_alias, 1);
3842
 
3843
  add_cmd ("map-overlay", class_support, map_overlay_command,
3844
           _("Assert that an overlay section is mapped."), &overlaylist);
3845
 
3846
  add_cmd ("unmap-overlay", class_support, unmap_overlay_command,
3847
           _("Assert that an overlay section is unmapped."), &overlaylist);
3848
 
3849
  add_cmd ("list-overlays", class_support, list_overlays_command,
3850
           _("List mappings of overlay sections."), &overlaylist);
3851
 
3852
  add_cmd ("manual", class_support, overlay_manual_command,
3853
           _("Enable overlay debugging."), &overlaylist);
3854
  add_cmd ("off", class_support, overlay_off_command,
3855
           _("Disable overlay debugging."), &overlaylist);
3856
  add_cmd ("auto", class_support, overlay_auto_command,
3857
           _("Enable automatic overlay debugging."), &overlaylist);
3858
  add_cmd ("load-target", class_support, overlay_load_command,
3859
           _("Read the overlay mapping state from the target."), &overlaylist);
3860
 
3861
  /* Filename extension to source language lookup table: */
3862
  init_filename_language_table ();
3863
  add_setshow_string_noescape_cmd ("extension-language", class_files,
3864
                                   &ext_args, _("\
3865
Set mapping between filename extension and source language."), _("\
3866
Show mapping between filename extension and source language."), _("\
3867
Usage: set extension-language .foo bar"),
3868
                                   set_ext_lang_command,
3869
                                   show_ext_args,
3870
                                   &setlist, &showlist);
3871
 
3872
  add_info ("extensions", info_ext_lang_command,
3873
            _("All filename extensions associated with a source language."));
3874
 
3875
  add_setshow_optional_filename_cmd ("debug-file-directory", class_support,
3876
                                     &debug_file_directory, _("\
3877
Set the directories where separate debug symbols are searched for."), _("\
3878
Show the directories where separate debug symbols are searched for."), _("\
3879
Separate debug symbols are first searched for in the same\n\
3880
directory as the binary, then in the `" DEBUG_SUBDIRECTORY "' subdirectory,\n\
3881
and lastly at the path of the directory of the binary with\n\
3882
each global debug-file-directory component prepended."),
3883
                                     NULL,
3884
                                     show_debug_file_directory,
3885
                                     &setlist, &showlist);
3886
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.