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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [gdb/] [symfile.c] - Blame information for rev 840

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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