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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [symtab.c] - Blame information for rev 157

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Symbol table lookup for the GNU debugger, GDB.
2
 
3
   Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4
   1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008
5
   Free Software Foundation, Inc.
6
 
7
   This file is part of GDB.
8
 
9
   This program is free software; you can redistribute it and/or modify
10
   it under the terms of the GNU General Public License as published by
11
   the Free Software Foundation; either version 3 of the License, or
12
   (at your option) any later version.
13
 
14
   This program is distributed in the hope that it will be useful,
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
   GNU General Public License for more details.
18
 
19
   You should have received a copy of the GNU General Public License
20
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
21
 
22
#include "defs.h"
23
#include "symtab.h"
24
#include "gdbtypes.h"
25
#include "gdbcore.h"
26
#include "frame.h"
27
#include "target.h"
28
#include "value.h"
29
#include "symfile.h"
30
#include "objfiles.h"
31
#include "gdbcmd.h"
32
#include "call-cmds.h"
33
#include "gdb_regex.h"
34
#include "expression.h"
35
#include "language.h"
36
#include "demangle.h"
37
#include "inferior.h"
38
#include "linespec.h"
39
#include "source.h"
40
#include "filenames.h"          /* for FILENAME_CMP */
41
#include "objc-lang.h"
42
#include "ada-lang.h"
43
#include "p-lang.h"
44
 
45
#include "hashtab.h"
46
 
47
#include "gdb_obstack.h"
48
#include "block.h"
49
#include "dictionary.h"
50
 
51
#include <sys/types.h>
52
#include <fcntl.h>
53
#include "gdb_string.h"
54
#include "gdb_stat.h"
55
#include <ctype.h>
56
#include "cp-abi.h"
57
#include "observer.h"
58
#include "gdb_assert.h"
59
#include "solist.h"
60
 
61
/* Prototypes for local functions */
62
 
63
static void completion_list_add_name (char *, char *, int, char *, char *);
64
 
65
static void rbreak_command (char *, int);
66
 
67
static void types_info (char *, int);
68
 
69
static void functions_info (char *, int);
70
 
71
static void variables_info (char *, int);
72
 
73
static void sources_info (char *, int);
74
 
75
static void output_source_filename (const char *, int *);
76
 
77
static int find_line_common (struct linetable *, int, int *);
78
 
79
/* This one is used by linespec.c */
80
 
81
char *operator_chars (char *p, char **end);
82
 
83
static struct symbol *lookup_symbol_aux (const char *name,
84
                                         const char *linkage_name,
85
                                         const struct block *block,
86
                                         const domain_enum domain,
87
                                         enum language language,
88
                                         int *is_a_field_of_this,
89
                                         struct symtab **symtab);
90
 
91
static
92
struct symbol *lookup_symbol_aux_local (const char *name,
93
                                        const char *linkage_name,
94
                                        const struct block *block,
95
                                        const domain_enum domain,
96
                                        struct symtab **symtab);
97
 
98
static
99
struct symbol *lookup_symbol_aux_symtabs (int block_index,
100
                                          const char *name,
101
                                          const char *linkage_name,
102
                                          const domain_enum domain,
103
                                          struct symtab **symtab);
104
 
105
static
106
struct symbol *lookup_symbol_aux_psymtabs (int block_index,
107
                                           const char *name,
108
                                           const char *linkage_name,
109
                                           const domain_enum domain,
110
                                           struct symtab **symtab);
111
 
112
static void fixup_section (struct general_symbol_info *, struct objfile *);
113
 
114
static int file_matches (char *, char **, int);
115
 
116
static void print_symbol_info (domain_enum,
117
                               struct symtab *, struct symbol *, int, char *);
118
 
119
static void print_msymbol_info (struct minimal_symbol *);
120
 
121
static void symtab_symbol_info (char *, domain_enum, int);
122
 
123
void _initialize_symtab (void);
124
 
125
/* */
126
 
127
/* The single non-language-specific builtin type */
128
struct type *builtin_type_error;
129
 
130
/* Block in which the most recently searched-for symbol was found.
131
   Might be better to make this a parameter to lookup_symbol and
132
   value_of_this. */
133
 
134
const struct block *block_found;
135
 
136
/* Check for a symtab of a specific name; first in symtabs, then in
137
   psymtabs.  *If* there is no '/' in the name, a match after a '/'
138
   in the symtab filename will also work.  */
139
 
140
struct symtab *
141
lookup_symtab (const char *name)
142
{
143
  struct symtab *s;
144
  struct partial_symtab *ps;
145
  struct objfile *objfile;
146
  char *real_path = NULL;
147
  char *full_path = NULL;
148
 
149
  /* Here we are interested in canonicalizing an absolute path, not
150
     absolutizing a relative path.  */
151
  if (IS_ABSOLUTE_PATH (name))
152
    {
153
      full_path = xfullpath (name);
154
      make_cleanup (xfree, full_path);
155
      real_path = gdb_realpath (name);
156
      make_cleanup (xfree, real_path);
157
    }
158
 
159
got_symtab:
160
 
161
  /* First, search for an exact match */
162
 
163
  ALL_SYMTABS (objfile, s)
164
  {
165
    if (FILENAME_CMP (name, s->filename) == 0)
166
      {
167
        return s;
168
      }
169
 
170
    /* If the user gave us an absolute path, try to find the file in
171
       this symtab and use its absolute path.  */
172
 
173
    if (full_path != NULL)
174
      {
175
        const char *fp = symtab_to_fullname (s);
176
        if (fp != NULL && FILENAME_CMP (full_path, fp) == 0)
177
          {
178
            return s;
179
          }
180
      }
181
 
182
    if (real_path != NULL)
183
      {
184
        char *fullname = symtab_to_fullname (s);
185
        if (fullname != NULL)
186
          {
187
            char *rp = gdb_realpath (fullname);
188
            make_cleanup (xfree, rp);
189
            if (FILENAME_CMP (real_path, rp) == 0)
190
              {
191
                return s;
192
              }
193
          }
194
      }
195
  }
196
 
197
  /* Now, search for a matching tail (only if name doesn't have any dirs) */
198
 
199
  if (lbasename (name) == name)
200
    ALL_SYMTABS (objfile, s)
201
    {
202
      if (FILENAME_CMP (lbasename (s->filename), name) == 0)
203
        return s;
204
    }
205
 
206
  /* Same search rules as above apply here, but now we look thru the
207
     psymtabs.  */
208
 
209
  ps = lookup_partial_symtab (name);
210
  if (!ps)
211
    return (NULL);
212
 
213
  if (ps->readin)
214
    error (_("Internal: readin %s pst for `%s' found when no symtab found."),
215
           ps->filename, name);
216
 
217
  s = PSYMTAB_TO_SYMTAB (ps);
218
 
219
  if (s)
220
    return s;
221
 
222
  /* At this point, we have located the psymtab for this file, but
223
     the conversion to a symtab has failed.  This usually happens
224
     when we are looking up an include file.  In this case,
225
     PSYMTAB_TO_SYMTAB doesn't return a symtab, even though one has
226
     been created.  So, we need to run through the symtabs again in
227
     order to find the file.
228
     XXX - This is a crock, and should be fixed inside of the the
229
     symbol parsing routines. */
230
  goto got_symtab;
231
}
232
 
233
/* Lookup the partial symbol table of a source file named NAME.
234
   *If* there is no '/' in the name, a match after a '/'
235
   in the psymtab filename will also work.  */
236
 
237
struct partial_symtab *
238
lookup_partial_symtab (const char *name)
239
{
240
  struct partial_symtab *pst;
241
  struct objfile *objfile;
242
  char *full_path = NULL;
243
  char *real_path = NULL;
244
 
245
  /* Here we are interested in canonicalizing an absolute path, not
246
     absolutizing a relative path.  */
247
  if (IS_ABSOLUTE_PATH (name))
248
    {
249
      full_path = xfullpath (name);
250
      make_cleanup (xfree, full_path);
251
      real_path = gdb_realpath (name);
252
      make_cleanup (xfree, real_path);
253
    }
254
 
255
  ALL_PSYMTABS (objfile, pst)
256
  {
257
    if (FILENAME_CMP (name, pst->filename) == 0)
258
      {
259
        return (pst);
260
      }
261
 
262
    /* If the user gave us an absolute path, try to find the file in
263
       this symtab and use its absolute path.  */
264
    if (full_path != NULL)
265
      {
266
        psymtab_to_fullname (pst);
267
        if (pst->fullname != NULL
268
            && FILENAME_CMP (full_path, pst->fullname) == 0)
269
          {
270
            return pst;
271
          }
272
      }
273
 
274
    if (real_path != NULL)
275
      {
276
        char *rp = NULL;
277
        psymtab_to_fullname (pst);
278
        if (pst->fullname != NULL)
279
          {
280
            rp = gdb_realpath (pst->fullname);
281
            make_cleanup (xfree, rp);
282
          }
283
        if (rp != NULL && FILENAME_CMP (real_path, rp) == 0)
284
          {
285
            return pst;
286
          }
287
      }
288
  }
289
 
290
  /* Now, search for a matching tail (only if name doesn't have any dirs) */
291
 
292
  if (lbasename (name) == name)
293
    ALL_PSYMTABS (objfile, pst)
294
    {
295
      if (FILENAME_CMP (lbasename (pst->filename), name) == 0)
296
        return (pst);
297
    }
298
 
299
  return (NULL);
300
}
301
 
302
/* Mangle a GDB method stub type.  This actually reassembles the pieces of the
303
   full method name, which consist of the class name (from T), the unadorned
304
   method name from METHOD_ID, and the signature for the specific overload,
305
   specified by SIGNATURE_ID.  Note that this function is g++ specific. */
306
 
307
char *
308
gdb_mangle_name (struct type *type, int method_id, int signature_id)
309
{
310
  int mangled_name_len;
311
  char *mangled_name;
312
  struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id);
313
  struct fn_field *method = &f[signature_id];
314
  char *field_name = TYPE_FN_FIELDLIST_NAME (type, method_id);
315
  char *physname = TYPE_FN_FIELD_PHYSNAME (f, signature_id);
316
  char *newname = type_name_no_tag (type);
317
 
318
  /* Does the form of physname indicate that it is the full mangled name
319
     of a constructor (not just the args)?  */
320
  int is_full_physname_constructor;
321
 
322
  int is_constructor;
323
  int is_destructor = is_destructor_name (physname);
324
  /* Need a new type prefix.  */
325
  char *const_prefix = method->is_const ? "C" : "";
326
  char *volatile_prefix = method->is_volatile ? "V" : "";
327
  char buf[20];
328
  int len = (newname == NULL ? 0 : strlen (newname));
329
 
330
  /* Nothing to do if physname already contains a fully mangled v3 abi name
331
     or an operator name.  */
332
  if ((physname[0] == '_' && physname[1] == 'Z')
333
      || is_operator_name (field_name))
334
    return xstrdup (physname);
335
 
336
  is_full_physname_constructor = is_constructor_name (physname);
337
 
338
  is_constructor =
339
    is_full_physname_constructor || (newname && strcmp (field_name, newname) == 0);
340
 
341
  if (!is_destructor)
342
    is_destructor = (strncmp (physname, "__dt", 4) == 0);
343
 
344
  if (is_destructor || is_full_physname_constructor)
345
    {
346
      mangled_name = (char *) xmalloc (strlen (physname) + 1);
347
      strcpy (mangled_name, physname);
348
      return mangled_name;
349
    }
350
 
351
  if (len == 0)
352
    {
353
      sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
354
    }
355
  else if (physname[0] == 't' || physname[0] == 'Q')
356
    {
357
      /* The physname for template and qualified methods already includes
358
         the class name.  */
359
      sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
360
      newname = NULL;
361
      len = 0;
362
    }
363
  else
364
    {
365
      sprintf (buf, "__%s%s%d", const_prefix, volatile_prefix, len);
366
    }
367
  mangled_name_len = ((is_constructor ? 0 : strlen (field_name))
368
                      + strlen (buf) + len + strlen (physname) + 1);
369
 
370
    {
371
      mangled_name = (char *) xmalloc (mangled_name_len);
372
      if (is_constructor)
373
        mangled_name[0] = '\0';
374
      else
375
        strcpy (mangled_name, field_name);
376
    }
377
  strcat (mangled_name, buf);
378
  /* If the class doesn't have a name, i.e. newname NULL, then we just
379
     mangle it using 0 for the length of the class.  Thus it gets mangled
380
     as something starting with `::' rather than `classname::'. */
381
  if (newname != NULL)
382
    strcat (mangled_name, newname);
383
 
384
  strcat (mangled_name, physname);
385
  return (mangled_name);
386
}
387
 
388
 
389
/* Initialize the language dependent portion of a symbol
390
   depending upon the language for the symbol. */
391
void
392
symbol_init_language_specific (struct general_symbol_info *gsymbol,
393
                               enum language language)
394
{
395
  gsymbol->language = language;
396
  if (gsymbol->language == language_cplus
397
      || gsymbol->language == language_java
398
      || gsymbol->language == language_objc)
399
    {
400
      gsymbol->language_specific.cplus_specific.demangled_name = NULL;
401
    }
402
  else
403
    {
404
      memset (&gsymbol->language_specific, 0,
405
              sizeof (gsymbol->language_specific));
406
    }
407
}
408
 
409
/* Functions to initialize a symbol's mangled name.  */
410
 
411
/* Create the hash table used for demangled names.  Each hash entry is
412
   a pair of strings; one for the mangled name and one for the demangled
413
   name.  The entry is hashed via just the mangled name.  */
414
 
415
static void
416
create_demangled_names_hash (struct objfile *objfile)
417
{
418
  /* Choose 256 as the starting size of the hash table, somewhat arbitrarily.
419
     The hash table code will round this up to the next prime number.
420
     Choosing a much larger table size wastes memory, and saves only about
421
     1% in symbol reading.  */
422
 
423
  objfile->demangled_names_hash = htab_create_alloc
424
    (256, htab_hash_string, (int (*) (const void *, const void *)) streq,
425
     NULL, xcalloc, xfree);
426
}
427
 
428
/* Try to determine the demangled name for a symbol, based on the
429
   language of that symbol.  If the language is set to language_auto,
430
   it will attempt to find any demangling algorithm that works and
431
   then set the language appropriately.  The returned name is allocated
432
   by the demangler and should be xfree'd.  */
433
 
434
static char *
435
symbol_find_demangled_name (struct general_symbol_info *gsymbol,
436
                            const char *mangled)
437
{
438
  char *demangled = NULL;
439
 
440
  if (gsymbol->language == language_unknown)
441
    gsymbol->language = language_auto;
442
 
443
  if (gsymbol->language == language_objc
444
      || gsymbol->language == language_auto)
445
    {
446
      demangled =
447
        objc_demangle (mangled, 0);
448
      if (demangled != NULL)
449
        {
450
          gsymbol->language = language_objc;
451
          return demangled;
452
        }
453
    }
454
  if (gsymbol->language == language_cplus
455
      || gsymbol->language == language_auto)
456
    {
457
      demangled =
458
        cplus_demangle (mangled, DMGL_PARAMS | DMGL_ANSI);
459
      if (demangled != NULL)
460
        {
461
          gsymbol->language = language_cplus;
462
          return demangled;
463
        }
464
    }
465
  if (gsymbol->language == language_java)
466
    {
467
      demangled =
468
        cplus_demangle (mangled,
469
                        DMGL_PARAMS | DMGL_ANSI | DMGL_JAVA);
470
      if (demangled != NULL)
471
        {
472
          gsymbol->language = language_java;
473
          return demangled;
474
        }
475
    }
476
  return NULL;
477
}
478
 
479
/* Set both the mangled and demangled (if any) names for GSYMBOL based
480
   on LINKAGE_NAME and LEN.  The hash table corresponding to OBJFILE
481
   is used, and the memory comes from that objfile's objfile_obstack.
482
   LINKAGE_NAME is copied, so the pointer can be discarded after
483
   calling this function.  */
484
 
485
/* We have to be careful when dealing with Java names: when we run
486
   into a Java minimal symbol, we don't know it's a Java symbol, so it
487
   gets demangled as a C++ name.  This is unfortunate, but there's not
488
   much we can do about it: but when demangling partial symbols and
489
   regular symbols, we'd better not reuse the wrong demangled name.
490
   (See PR gdb/1039.)  We solve this by putting a distinctive prefix
491
   on Java names when storing them in the hash table.  */
492
 
493
/* FIXME: carlton/2003-03-13: This is an unfortunate situation.  I
494
   don't mind the Java prefix so much: different languages have
495
   different demangling requirements, so it's only natural that we
496
   need to keep language data around in our demangling cache.  But
497
   it's not good that the minimal symbol has the wrong demangled name.
498
   Unfortunately, I can't think of any easy solution to that
499
   problem.  */
500
 
501
#define JAVA_PREFIX "##JAVA$$"
502
#define JAVA_PREFIX_LEN 8
503
 
504
void
505
symbol_set_names (struct general_symbol_info *gsymbol,
506
                  const char *linkage_name, int len, struct objfile *objfile)
507
{
508
  char **slot;
509
  /* A 0-terminated copy of the linkage name.  */
510
  const char *linkage_name_copy;
511
  /* A copy of the linkage name that might have a special Java prefix
512
     added to it, for use when looking names up in the hash table.  */
513
  const char *lookup_name;
514
  /* The length of lookup_name.  */
515
  int lookup_len;
516
 
517
  if (objfile->demangled_names_hash == NULL)
518
    create_demangled_names_hash (objfile);
519
 
520
  if (gsymbol->language == language_ada)
521
    {
522
      /* In Ada, we do the symbol lookups using the mangled name, so
523
         we can save some space by not storing the demangled name.
524
 
525
         As a side note, we have also observed some overlap between
526
         the C++ mangling and Ada mangling, similarly to what has
527
         been observed with Java.  Because we don't store the demangled
528
         name with the symbol, we don't need to use the same trick
529
         as Java.  */
530
      gsymbol->name = obstack_alloc (&objfile->objfile_obstack, len + 1);
531
      memcpy (gsymbol->name, linkage_name, len);
532
      gsymbol->name[len] = '\0';
533
      gsymbol->language_specific.cplus_specific.demangled_name = NULL;
534
 
535
      return;
536
    }
537
 
538
  /* The stabs reader generally provides names that are not
539
     NUL-terminated; most of the other readers don't do this, so we
540
     can just use the given copy, unless we're in the Java case.  */
541
  if (gsymbol->language == language_java)
542
    {
543
      char *alloc_name;
544
      lookup_len = len + JAVA_PREFIX_LEN;
545
 
546
      alloc_name = alloca (lookup_len + 1);
547
      memcpy (alloc_name, JAVA_PREFIX, JAVA_PREFIX_LEN);
548
      memcpy (alloc_name + JAVA_PREFIX_LEN, linkage_name, len);
549
      alloc_name[lookup_len] = '\0';
550
 
551
      lookup_name = alloc_name;
552
      linkage_name_copy = alloc_name + JAVA_PREFIX_LEN;
553
    }
554
  else if (linkage_name[len] != '\0')
555
    {
556
      char *alloc_name;
557
      lookup_len = len;
558
 
559
      alloc_name = alloca (lookup_len + 1);
560
      memcpy (alloc_name, linkage_name, len);
561
      alloc_name[lookup_len] = '\0';
562
 
563
      lookup_name = alloc_name;
564
      linkage_name_copy = alloc_name;
565
    }
566
  else
567
    {
568
      lookup_len = len;
569
      lookup_name = linkage_name;
570
      linkage_name_copy = linkage_name;
571
    }
572
 
573
  slot = (char **) htab_find_slot (objfile->demangled_names_hash,
574
                                   lookup_name, INSERT);
575
 
576
  /* If this name is not in the hash table, add it.  */
577
  if (*slot == NULL)
578
    {
579
      char *demangled_name = symbol_find_demangled_name (gsymbol,
580
                                                         linkage_name_copy);
581
      int demangled_len = demangled_name ? strlen (demangled_name) : 0;
582
 
583
      /* If there is a demangled name, place it right after the mangled name.
584
         Otherwise, just place a second zero byte after the end of the mangled
585
         name.  */
586
      *slot = obstack_alloc (&objfile->objfile_obstack,
587
                             lookup_len + demangled_len + 2);
588
      memcpy (*slot, lookup_name, lookup_len + 1);
589
      if (demangled_name != NULL)
590
        {
591
          memcpy (*slot + lookup_len + 1, demangled_name, demangled_len + 1);
592
          xfree (demangled_name);
593
        }
594
      else
595
        (*slot)[lookup_len + 1] = '\0';
596
    }
597
 
598
  gsymbol->name = *slot + lookup_len - len;
599
  if ((*slot)[lookup_len + 1] != '\0')
600
    gsymbol->language_specific.cplus_specific.demangled_name
601
      = &(*slot)[lookup_len + 1];
602
  else
603
    gsymbol->language_specific.cplus_specific.demangled_name = NULL;
604
}
605
 
606
/* Initialize the demangled name of GSYMBOL if possible.  Any required space
607
   to store the name is obtained from the specified obstack.  The function
608
   symbol_set_names, above, should be used instead where possible for more
609
   efficient memory usage.  */
610
 
611
void
612
symbol_init_demangled_name (struct general_symbol_info *gsymbol,
613
                            struct obstack *obstack)
614
{
615
  char *mangled = gsymbol->name;
616
  char *demangled = NULL;
617
 
618
  demangled = symbol_find_demangled_name (gsymbol, mangled);
619
  if (gsymbol->language == language_cplus
620
      || gsymbol->language == language_java
621
      || gsymbol->language == language_objc)
622
    {
623
      if (demangled)
624
        {
625
          gsymbol->language_specific.cplus_specific.demangled_name
626
            = obsavestring (demangled, strlen (demangled), obstack);
627
          xfree (demangled);
628
        }
629
      else
630
        gsymbol->language_specific.cplus_specific.demangled_name = NULL;
631
    }
632
  else
633
    {
634
      /* Unknown language; just clean up quietly.  */
635
      if (demangled)
636
        xfree (demangled);
637
    }
638
}
639
 
640
/* Return the source code name of a symbol.  In languages where
641
   demangling is necessary, this is the demangled name.  */
642
 
643
char *
644
symbol_natural_name (const struct general_symbol_info *gsymbol)
645
{
646
  switch (gsymbol->language)
647
    {
648
    case language_cplus:
649
    case language_java:
650
    case language_objc:
651
      if (gsymbol->language_specific.cplus_specific.demangled_name != NULL)
652
        return gsymbol->language_specific.cplus_specific.demangled_name;
653
      break;
654
    case language_ada:
655
      if (gsymbol->language_specific.cplus_specific.demangled_name != NULL)
656
        return gsymbol->language_specific.cplus_specific.demangled_name;
657
      else
658
        return ada_decode_symbol (gsymbol);
659
      break;
660
    default:
661
      break;
662
    }
663
  return gsymbol->name;
664
}
665
 
666
/* Return the demangled name for a symbol based on the language for
667
   that symbol.  If no demangled name exists, return NULL. */
668
char *
669
symbol_demangled_name (struct general_symbol_info *gsymbol)
670
{
671
  switch (gsymbol->language)
672
    {
673
    case language_cplus:
674
    case language_java:
675
    case language_objc:
676
      if (gsymbol->language_specific.cplus_specific.demangled_name != NULL)
677
        return gsymbol->language_specific.cplus_specific.demangled_name;
678
      break;
679
    case language_ada:
680
      if (gsymbol->language_specific.cplus_specific.demangled_name != NULL)
681
        return gsymbol->language_specific.cplus_specific.demangled_name;
682
      else
683
        return ada_decode_symbol (gsymbol);
684
      break;
685
    default:
686
      break;
687
    }
688
  return NULL;
689
}
690
 
691
/* Return the search name of a symbol---generally the demangled or
692
   linkage name of the symbol, depending on how it will be searched for.
693
   If there is no distinct demangled name, then returns the same value
694
   (same pointer) as SYMBOL_LINKAGE_NAME. */
695
char *
696
symbol_search_name (const struct general_symbol_info *gsymbol)
697
{
698
  if (gsymbol->language == language_ada)
699
    return gsymbol->name;
700
  else
701
    return symbol_natural_name (gsymbol);
702
}
703
 
704
/* Initialize the structure fields to zero values.  */
705
void
706
init_sal (struct symtab_and_line *sal)
707
{
708
  sal->symtab = 0;
709
  sal->section = 0;
710
  sal->line = 0;
711
  sal->pc = 0;
712
  sal->end = 0;
713
  sal->explicit_pc = 0;
714
  sal->explicit_line = 0;
715
}
716
 
717
 
718
/* Return 1 if the two sections are the same, or if they could
719
   plausibly be copies of each other, one in an original object
720
   file and another in a separated debug file.  */
721
 
722
int
723
matching_bfd_sections (asection *first, asection *second)
724
{
725
  struct objfile *obj;
726
 
727
  /* If they're the same section, then they match.  */
728
  if (first == second)
729
    return 1;
730
 
731
  /* If either is NULL, give up.  */
732
  if (first == NULL || second == NULL)
733
    return 0;
734
 
735
  /* This doesn't apply to absolute symbols.  */
736
  if (first->owner == NULL || second->owner == NULL)
737
    return 0;
738
 
739
  /* If they're in the same object file, they must be different sections.  */
740
  if (first->owner == second->owner)
741
    return 0;
742
 
743
  /* Check whether the two sections are potentially corresponding.  They must
744
     have the same size, address, and name.  We can't compare section indexes,
745
     which would be more reliable, because some sections may have been
746
     stripped.  */
747
  if (bfd_get_section_size (first) != bfd_get_section_size (second))
748
    return 0;
749
 
750
  /* In-memory addresses may start at a different offset, relativize them.  */
751
  if (bfd_get_section_vma (first->owner, first)
752
      - bfd_get_start_address (first->owner)
753
      != bfd_get_section_vma (second->owner, second)
754
         - bfd_get_start_address (second->owner))
755
    return 0;
756
 
757
  if (bfd_get_section_name (first->owner, first) == NULL
758
      || bfd_get_section_name (second->owner, second) == NULL
759
      || strcmp (bfd_get_section_name (first->owner, first),
760
                 bfd_get_section_name (second->owner, second)) != 0)
761
    return 0;
762
 
763
  /* Otherwise check that they are in corresponding objfiles.  */
764
 
765
  ALL_OBJFILES (obj)
766
    if (obj->obfd == first->owner)
767
      break;
768
  gdb_assert (obj != NULL);
769
 
770
  if (obj->separate_debug_objfile != NULL
771
      && obj->separate_debug_objfile->obfd == second->owner)
772
    return 1;
773
  if (obj->separate_debug_objfile_backlink != NULL
774
      && obj->separate_debug_objfile_backlink->obfd == second->owner)
775
    return 1;
776
 
777
  return 0;
778
}
779
 
780
/* Find which partial symtab contains PC and SECTION.  Return 0 if
781
   none.  We return the psymtab that contains a symbol whose address
782
   exactly matches PC, or, if we cannot find an exact match, the
783
   psymtab that contains a symbol whose address is closest to PC.  */
784
struct partial_symtab *
785
find_pc_sect_psymtab (CORE_ADDR pc, asection *section)
786
{
787
  struct partial_symtab *pst;
788
  struct objfile *objfile;
789
  struct minimal_symbol *msymbol;
790
 
791
  /* If we know that this is not a text address, return failure.  This is
792
     necessary because we loop based on texthigh and textlow, which do
793
     not include the data ranges.  */
794
  msymbol = lookup_minimal_symbol_by_pc_section (pc, section);
795
  if (msymbol
796
      && (msymbol->type == mst_data
797
          || msymbol->type == mst_bss
798
          || msymbol->type == mst_abs
799
          || msymbol->type == mst_file_data
800
          || msymbol->type == mst_file_bss))
801
    return NULL;
802
 
803
  ALL_PSYMTABS (objfile, pst)
804
  {
805
    if (pc >= pst->textlow && pc < pst->texthigh)
806
      {
807
        struct partial_symtab *tpst;
808
        struct partial_symtab *best_pst = pst;
809
        CORE_ADDR best_addr = pst->textlow;
810
 
811
        /* An objfile that has its functions reordered might have
812
           many partial symbol tables containing the PC, but
813
           we want the partial symbol table that contains the
814
           function containing the PC.  */
815
        if (!(objfile->flags & OBJF_REORDERED) &&
816
            section == 0)        /* can't validate section this way */
817
          return (pst);
818
 
819
        if (msymbol == NULL)
820
          return (pst);
821
 
822
        /* The code range of partial symtabs sometimes overlap, so, in
823
           the loop below, we need to check all partial symtabs and
824
           find the one that fits better for the given PC address. We
825
           select the partial symtab that contains a symbol whose
826
           address is closest to the PC address.  By closest we mean
827
           that find_pc_sect_symbol returns the symbol with address
828
           that is closest and still less than the given PC.  */
829
        for (tpst = pst; tpst != NULL; tpst = tpst->next)
830
          {
831
            if (pc >= tpst->textlow && pc < tpst->texthigh)
832
              {
833
                struct partial_symbol *p;
834
                CORE_ADDR this_addr;
835
 
836
                /* NOTE: This assumes that every psymbol has a
837
                   corresponding msymbol, which is not necessarily
838
                   true; the debug info might be much richer than the
839
                   object's symbol table.  */
840
                p = find_pc_sect_psymbol (tpst, pc, section);
841
                if (p != NULL
842
                    && SYMBOL_VALUE_ADDRESS (p)
843
                    == SYMBOL_VALUE_ADDRESS (msymbol))
844
                  return (tpst);
845
 
846
                /* Also accept the textlow value of a psymtab as a
847
                   "symbol", to provide some support for partial
848
                   symbol tables with line information but no debug
849
                   symbols (e.g. those produced by an assembler).  */
850
                if (p != NULL)
851
                  this_addr = SYMBOL_VALUE_ADDRESS (p);
852
                else
853
                  this_addr = tpst->textlow;
854
 
855
                /* Check whether it is closer than our current
856
                   BEST_ADDR.  Since this symbol address is
857
                   necessarily lower or equal to PC, the symbol closer
858
                   to PC is the symbol which address is the highest.
859
                   This way we return the psymtab which contains such
860
                   best match symbol. This can help in cases where the
861
                   symbol information/debuginfo is not complete, like
862
                   for instance on IRIX6 with gcc, where no debug info
863
                   is emitted for statics. (See also the nodebug.exp
864
                   testcase.) */
865
                if (this_addr > best_addr)
866
                  {
867
                    best_addr = this_addr;
868
                    best_pst = tpst;
869
                  }
870
              }
871
          }
872
        return (best_pst);
873
      }
874
  }
875
  return (NULL);
876
}
877
 
878
/* Find which partial symtab contains PC.  Return 0 if none.
879
   Backward compatibility, no section */
880
 
881
struct partial_symtab *
882
find_pc_psymtab (CORE_ADDR pc)
883
{
884
  return find_pc_sect_psymtab (pc, find_pc_mapped_section (pc));
885
}
886
 
887
/* Find which partial symbol within a psymtab matches PC and SECTION.
888
   Return 0 if none.  Check all psymtabs if PSYMTAB is 0.  */
889
 
890
struct partial_symbol *
891
find_pc_sect_psymbol (struct partial_symtab *psymtab, CORE_ADDR pc,
892
                      asection *section)
893
{
894
  struct partial_symbol *best = NULL, *p, **pp;
895
  CORE_ADDR best_pc;
896
 
897
  if (!psymtab)
898
    psymtab = find_pc_sect_psymtab (pc, section);
899
  if (!psymtab)
900
    return 0;
901
 
902
  /* Cope with programs that start at address 0 */
903
  best_pc = (psymtab->textlow != 0) ? psymtab->textlow - 1 : 0;
904
 
905
  /* Search the global symbols as well as the static symbols, so that
906
     find_pc_partial_function doesn't use a minimal symbol and thus
907
     cache a bad endaddr.  */
908
  for (pp = psymtab->objfile->global_psymbols.list + psymtab->globals_offset;
909
    (pp - (psymtab->objfile->global_psymbols.list + psymtab->globals_offset)
910
     < psymtab->n_global_syms);
911
       pp++)
912
    {
913
      p = *pp;
914
      if (SYMBOL_DOMAIN (p) == VAR_DOMAIN
915
          && SYMBOL_CLASS (p) == LOC_BLOCK
916
          && pc >= SYMBOL_VALUE_ADDRESS (p)
917
          && (SYMBOL_VALUE_ADDRESS (p) > best_pc
918
              || (psymtab->textlow == 0
919
                  && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0)))
920
        {
921
          if (section)          /* match on a specific section */
922
            {
923
              fixup_psymbol_section (p, psymtab->objfile);
924
              if (!matching_bfd_sections (SYMBOL_BFD_SECTION (p), section))
925
                continue;
926
            }
927
          best_pc = SYMBOL_VALUE_ADDRESS (p);
928
          best = p;
929
        }
930
    }
931
 
932
  for (pp = psymtab->objfile->static_psymbols.list + psymtab->statics_offset;
933
    (pp - (psymtab->objfile->static_psymbols.list + psymtab->statics_offset)
934
     < psymtab->n_static_syms);
935
       pp++)
936
    {
937
      p = *pp;
938
      if (SYMBOL_DOMAIN (p) == VAR_DOMAIN
939
          && SYMBOL_CLASS (p) == LOC_BLOCK
940
          && pc >= SYMBOL_VALUE_ADDRESS (p)
941
          && (SYMBOL_VALUE_ADDRESS (p) > best_pc
942
              || (psymtab->textlow == 0
943
                  && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0)))
944
        {
945
          if (section)          /* match on a specific section */
946
            {
947
              fixup_psymbol_section (p, psymtab->objfile);
948
              if (!matching_bfd_sections (SYMBOL_BFD_SECTION (p), section))
949
                continue;
950
            }
951
          best_pc = SYMBOL_VALUE_ADDRESS (p);
952
          best = p;
953
        }
954
    }
955
 
956
  return best;
957
}
958
 
959
/* Find which partial symbol within a psymtab matches PC.  Return 0 if none.
960
   Check all psymtabs if PSYMTAB is 0.  Backwards compatibility, no section. */
961
 
962
struct partial_symbol *
963
find_pc_psymbol (struct partial_symtab *psymtab, CORE_ADDR pc)
964
{
965
  return find_pc_sect_psymbol (psymtab, pc, find_pc_mapped_section (pc));
966
}
967
 
968
/* Debug symbols usually don't have section information.  We need to dig that
969
   out of the minimal symbols and stash that in the debug symbol.  */
970
 
971
static void
972
fixup_section (struct general_symbol_info *ginfo, struct objfile *objfile)
973
{
974
  struct minimal_symbol *msym;
975
  msym = lookup_minimal_symbol (ginfo->name, NULL, objfile);
976
 
977
  if (msym)
978
    {
979
      ginfo->bfd_section = SYMBOL_BFD_SECTION (msym);
980
      ginfo->section = SYMBOL_SECTION (msym);
981
    }
982
  else if (objfile)
983
    {
984
      /* Static, function-local variables do appear in the linker
985
         (minimal) symbols, but are frequently given names that won't
986
         be found via lookup_minimal_symbol().  E.g., it has been
987
         observed in frv-uclinux (ELF) executables that a static,
988
         function-local variable named "foo" might appear in the
989
         linker symbols as "foo.6" or "foo.3".  Thus, there is no
990
         point in attempting to extend the lookup-by-name mechanism to
991
         handle this case due to the fact that there can be multiple
992
         names.
993
 
994
         So, instead, search the section table when lookup by name has
995
         failed.  The ``addr'' and ``endaddr'' fields may have already
996
         been relocated.  If so, the relocation offset (i.e. the
997
         ANOFFSET value) needs to be subtracted from these values when
998
         performing the comparison.  We unconditionally subtract it,
999
         because, when no relocation has been performed, the ANOFFSET
1000
         value will simply be zero.
1001
 
1002
         The address of the symbol whose section we're fixing up HAS
1003
         NOT BEEN adjusted (relocated) yet.  It can't have been since
1004
         the section isn't yet known and knowing the section is
1005
         necessary in order to add the correct relocation value.  In
1006
         other words, we wouldn't even be in this function (attempting
1007
         to compute the section) if it were already known.
1008
 
1009
         Note that it is possible to search the minimal symbols
1010
         (subtracting the relocation value if necessary) to find the
1011
         matching minimal symbol, but this is overkill and much less
1012
         efficient.  It is not necessary to find the matching minimal
1013
         symbol, only its section.
1014
 
1015
         Note that this technique (of doing a section table search)
1016
         can fail when unrelocated section addresses overlap.  For
1017
         this reason, we still attempt a lookup by name prior to doing
1018
         a search of the section table.  */
1019
 
1020
      CORE_ADDR addr;
1021
      struct obj_section *s;
1022
 
1023
      addr = ginfo->value.address;
1024
 
1025
      ALL_OBJFILE_OSECTIONS (objfile, s)
1026
        {
1027
          int idx = s->the_bfd_section->index;
1028
          CORE_ADDR offset = ANOFFSET (objfile->section_offsets, idx);
1029
 
1030
          if (s->addr - offset <= addr && addr < s->endaddr - offset)
1031
            {
1032
              ginfo->bfd_section = s->the_bfd_section;
1033
              ginfo->section = idx;
1034
              return;
1035
            }
1036
        }
1037
    }
1038
}
1039
 
1040
struct symbol *
1041
fixup_symbol_section (struct symbol *sym, struct objfile *objfile)
1042
{
1043
  if (!sym)
1044
    return NULL;
1045
 
1046
  if (SYMBOL_BFD_SECTION (sym))
1047
    return sym;
1048
 
1049
  fixup_section (&sym->ginfo, objfile);
1050
 
1051
  return sym;
1052
}
1053
 
1054
struct partial_symbol *
1055
fixup_psymbol_section (struct partial_symbol *psym, struct objfile *objfile)
1056
{
1057
  if (!psym)
1058
    return NULL;
1059
 
1060
  if (SYMBOL_BFD_SECTION (psym))
1061
    return psym;
1062
 
1063
  fixup_section (&psym->ginfo, objfile);
1064
 
1065
  return psym;
1066
}
1067
 
1068
/* Find the definition for a specified symbol name NAME
1069
   in domain DOMAIN, visible from lexical block BLOCK.
1070
   Returns the struct symbol pointer, or zero if no symbol is found.
1071
   If SYMTAB is non-NULL, store the symbol table in which the
1072
   symbol was found there, or NULL if not found.
1073
   C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
1074
   NAME is a field of the current implied argument `this'.  If so set
1075
   *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
1076
   BLOCK_FOUND is set to the block in which NAME is found (in the case of
1077
   a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
1078
 
1079
/* This function has a bunch of loops in it and it would seem to be
1080
   attractive to put in some QUIT's (though I'm not really sure
1081
   whether it can run long enough to be really important).  But there
1082
   are a few calls for which it would appear to be bad news to quit
1083
   out of here: find_proc_desc in alpha-tdep.c and mips-tdep.c.  (Note
1084
   that there is C++ code below which can error(), but that probably
1085
   doesn't affect these calls since they are looking for a known
1086
   variable and thus can probably assume it will never hit the C++
1087
   code).  */
1088
 
1089
struct symbol *
1090
lookup_symbol_in_language (const char *name, const struct block *block,
1091
                           const domain_enum domain, enum language lang,
1092
                           int *is_a_field_of_this,
1093
                           struct symtab **symtab)
1094
{
1095
  char *demangled_name = NULL;
1096
  const char *modified_name = NULL;
1097
  const char *mangled_name = NULL;
1098
  int needtofreename = 0;
1099
  struct symbol *returnval;
1100
 
1101
  modified_name = name;
1102
 
1103
  /* If we are using C++ or Java, demangle the name before doing a lookup, so
1104
     we can always binary search. */
1105
  if (lang == language_cplus)
1106
    {
1107
      demangled_name = cplus_demangle (name, DMGL_ANSI | DMGL_PARAMS);
1108
      if (demangled_name)
1109
        {
1110
          mangled_name = name;
1111
          modified_name = demangled_name;
1112
          needtofreename = 1;
1113
        }
1114
    }
1115
  else if (lang == language_java)
1116
    {
1117
      demangled_name = cplus_demangle (name,
1118
                                       DMGL_ANSI | DMGL_PARAMS | DMGL_JAVA);
1119
      if (demangled_name)
1120
        {
1121
          mangled_name = name;
1122
          modified_name = demangled_name;
1123
          needtofreename = 1;
1124
        }
1125
    }
1126
 
1127
  if (case_sensitivity == case_sensitive_off)
1128
    {
1129
      char *copy;
1130
      int len, i;
1131
 
1132
      len = strlen (name);
1133
      copy = (char *) alloca (len + 1);
1134
      for (i= 0; i < len; i++)
1135
        copy[i] = tolower (name[i]);
1136
      copy[len] = 0;
1137
      modified_name = copy;
1138
    }
1139
 
1140
  returnval = lookup_symbol_aux (modified_name, mangled_name, block,
1141
                                 domain, lang,
1142
                                 is_a_field_of_this, symtab);
1143
  if (needtofreename)
1144
    xfree (demangled_name);
1145
 
1146
  /* Override the returned symtab with the symbol's specific one.  */
1147
  if (returnval != NULL && symtab != NULL)
1148
    *symtab = SYMBOL_SYMTAB (returnval);
1149
 
1150
  return returnval;
1151
}
1152
 
1153
/* Behave like lookup_symbol_in_language, but performed with the
1154
   current language.  */
1155
 
1156
struct symbol *
1157
lookup_symbol (const char *name, const struct block *block,
1158
               domain_enum domain, int *is_a_field_of_this,
1159
               struct symtab **symtab)
1160
{
1161
  return lookup_symbol_in_language (name, block, domain,
1162
                                    current_language->la_language,
1163
                                    is_a_field_of_this, symtab);
1164
}
1165
 
1166
/* Behave like lookup_symbol except that NAME is the natural name
1167
   of the symbol that we're looking for and, if LINKAGE_NAME is
1168
   non-NULL, ensure that the symbol's linkage name matches as
1169
   well.  */
1170
 
1171
static struct symbol *
1172
lookup_symbol_aux (const char *name, const char *linkage_name,
1173
                   const struct block *block, const domain_enum domain,
1174
                   enum language language,
1175
                   int *is_a_field_of_this, struct symtab **symtab)
1176
{
1177
  struct symbol *sym;
1178
  const struct language_defn *langdef;
1179
 
1180
  /* Make sure we do something sensible with is_a_field_of_this, since
1181
     the callers that set this parameter to some non-null value will
1182
     certainly use it later and expect it to be either 0 or 1.
1183
     If we don't set it, the contents of is_a_field_of_this are
1184
     undefined.  */
1185
  if (is_a_field_of_this != NULL)
1186
    *is_a_field_of_this = 0;
1187
 
1188
  /* Search specified block and its superiors.  Don't search
1189
     STATIC_BLOCK or GLOBAL_BLOCK.  */
1190
 
1191
  sym = lookup_symbol_aux_local (name, linkage_name, block, domain,
1192
                                 symtab);
1193
  if (sym != NULL)
1194
    return sym;
1195
 
1196
  /* If requested to do so by the caller and if appropriate for LANGUAGE,
1197
     check to see if NAME is a field of `this'. */
1198
 
1199
  langdef = language_def (language);
1200
 
1201
  if (langdef->la_value_of_this != NULL
1202
      && is_a_field_of_this != NULL)
1203
    {
1204
      struct value *v = langdef->la_value_of_this (0);
1205
 
1206
      if (v && check_field (v, name))
1207
        {
1208
          *is_a_field_of_this = 1;
1209
          if (symtab != NULL)
1210
            *symtab = NULL;
1211
          return NULL;
1212
        }
1213
    }
1214
 
1215
  /* Now do whatever is appropriate for LANGUAGE to look
1216
     up static and global variables.  */
1217
 
1218
  sym = langdef->la_lookup_symbol_nonlocal (name, linkage_name,
1219
                                             block, domain, symtab);
1220
  if (sym != NULL)
1221
    return sym;
1222
 
1223
  /* Now search all static file-level symbols.  Not strictly correct,
1224
     but more useful than an error.  Do the symtabs first, then check
1225
     the psymtabs.  If a psymtab indicates the existence of the
1226
     desired name as a file-level static, then do psymtab-to-symtab
1227
     conversion on the fly and return the found symbol. */
1228
 
1229
  sym = lookup_symbol_aux_symtabs (STATIC_BLOCK, name, linkage_name,
1230
                                   domain, symtab);
1231
  if (sym != NULL)
1232
    return sym;
1233
 
1234
  sym = lookup_symbol_aux_psymtabs (STATIC_BLOCK, name, linkage_name,
1235
                                    domain, symtab);
1236
  if (sym != NULL)
1237
    return sym;
1238
 
1239
  if (symtab != NULL)
1240
    *symtab = NULL;
1241
  return NULL;
1242
}
1243
 
1244
/* Check to see if the symbol is defined in BLOCK or its superiors.
1245
   Don't search STATIC_BLOCK or GLOBAL_BLOCK.  */
1246
 
1247
static struct symbol *
1248
lookup_symbol_aux_local (const char *name, const char *linkage_name,
1249
                         const struct block *block,
1250
                         const domain_enum domain,
1251
                         struct symtab **symtab)
1252
{
1253
  struct symbol *sym;
1254
  const struct block *static_block = block_static_block (block);
1255
 
1256
  /* Check if either no block is specified or it's a global block.  */
1257
 
1258
  if (static_block == NULL)
1259
    return NULL;
1260
 
1261
  while (block != static_block)
1262
    {
1263
      sym = lookup_symbol_aux_block (name, linkage_name, block, domain,
1264
                                     symtab);
1265
      if (sym != NULL)
1266
        return sym;
1267
      block = BLOCK_SUPERBLOCK (block);
1268
    }
1269
 
1270
  /* We've reached the static block without finding a result.  */
1271
 
1272
  return NULL;
1273
}
1274
 
1275
/* Look up OBJFILE to BLOCK.  */
1276
 
1277
static struct objfile *
1278
lookup_objfile_from_block (const struct block *block)
1279
{
1280
  struct objfile *obj;
1281
  struct symtab *s;
1282
 
1283
  if (block == NULL)
1284
    return NULL;
1285
 
1286
  block = block_global_block (block);
1287
  /* Go through SYMTABS.  */
1288
  ALL_SYMTABS (obj, s)
1289
    if (block == BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK))
1290
      return obj;
1291
 
1292
  return NULL;
1293
}
1294
 
1295
/* Look up a symbol in a block; if found, locate its symtab, fixup the
1296
   symbol, and set block_found appropriately.  */
1297
 
1298
struct symbol *
1299
lookup_symbol_aux_block (const char *name, const char *linkage_name,
1300
                         const struct block *block,
1301
                         const domain_enum domain,
1302
                         struct symtab **symtab)
1303
{
1304
  struct symbol *sym;
1305
  struct objfile *objfile = NULL;
1306
  struct blockvector *bv;
1307
  struct block *b;
1308
  struct symtab *s = NULL;
1309
 
1310
  sym = lookup_block_symbol (block, name, linkage_name, domain);
1311
  if (sym)
1312
    {
1313
      block_found = block;
1314
      if (symtab != NULL)
1315
        {
1316
          /* Search the list of symtabs for one which contains the
1317
             address of the start of this block.  */
1318
          ALL_PRIMARY_SYMTABS (objfile, s)
1319
            {
1320
              bv = BLOCKVECTOR (s);
1321
              b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1322
              if (BLOCK_START (b) <= BLOCK_START (block)
1323
                  && BLOCK_END (b) > BLOCK_START (block))
1324
                goto found;
1325
            }
1326
        found:
1327
          *symtab = s;
1328
        }
1329
 
1330
      return fixup_symbol_section (sym, objfile);
1331
    }
1332
 
1333
  return NULL;
1334
}
1335
 
1336
/* Check all global symbols in OBJFILE in symtabs and
1337
   psymtabs.  */
1338
 
1339
struct symbol *
1340
lookup_global_symbol_from_objfile (const struct objfile *objfile,
1341
                                   const char *name,
1342
                                   const char *linkage_name,
1343
                                   const domain_enum domain,
1344
                                   struct symtab **symtab)
1345
{
1346
  struct symbol *sym;
1347
  struct blockvector *bv;
1348
  const struct block *block;
1349
  struct symtab *s;
1350
  struct partial_symtab *ps;
1351
 
1352
  /* Go through symtabs.  */
1353
  ALL_OBJFILE_SYMTABS (objfile, s)
1354
  {
1355
    bv = BLOCKVECTOR (s);
1356
    block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1357
    sym = lookup_block_symbol (block, name, linkage_name, domain);
1358
    if (sym)
1359
      {
1360
        block_found = block;
1361
        if (symtab != NULL)
1362
          *symtab = s;
1363
        return fixup_symbol_section (sym, (struct objfile *)objfile);
1364
      }
1365
  }
1366
 
1367
  /* Now go through psymtabs.  */
1368
  ALL_OBJFILE_PSYMTABS (objfile, ps)
1369
  {
1370
    if (!ps->readin
1371
        && lookup_partial_symbol (ps, name, linkage_name,
1372
                                  1, domain))
1373
      {
1374
        s = PSYMTAB_TO_SYMTAB (ps);
1375
        bv = BLOCKVECTOR (s);
1376
        block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1377
        sym = lookup_block_symbol (block, name, linkage_name, domain);
1378
        if (symtab != NULL)
1379
          *symtab = s;
1380
        return fixup_symbol_section (sym, (struct objfile *)objfile);
1381
      }
1382
  }
1383
 
1384
  if (objfile->separate_debug_objfile)
1385
    return lookup_global_symbol_from_objfile (objfile->separate_debug_objfile,
1386
                                              name, linkage_name, domain,
1387
                                              symtab);
1388
 
1389
  return NULL;
1390
}
1391
 
1392
/* Check to see if the symbol is defined in one of the symtabs.
1393
   BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
1394
   depending on whether or not we want to search global symbols or
1395
   static symbols.  */
1396
 
1397
static struct symbol *
1398
lookup_symbol_aux_symtabs (int block_index,
1399
                           const char *name, const char *linkage_name,
1400
                           const domain_enum domain,
1401
                           struct symtab **symtab)
1402
{
1403
  struct symbol *sym;
1404
  struct objfile *objfile;
1405
  struct blockvector *bv;
1406
  const struct block *block;
1407
  struct symtab *s;
1408
 
1409
  ALL_PRIMARY_SYMTABS (objfile, s)
1410
  {
1411
    bv = BLOCKVECTOR (s);
1412
    block = BLOCKVECTOR_BLOCK (bv, block_index);
1413
    sym = lookup_block_symbol (block, name, linkage_name, domain);
1414
    if (sym)
1415
      {
1416
        block_found = block;
1417
        if (symtab != NULL)
1418
          *symtab = s;
1419
        return fixup_symbol_section (sym, objfile);
1420
      }
1421
  }
1422
 
1423
  return NULL;
1424
}
1425
 
1426
/* Check to see if the symbol is defined in one of the partial
1427
   symtabs.  BLOCK_INDEX should be either GLOBAL_BLOCK or
1428
   STATIC_BLOCK, depending on whether or not we want to search global
1429
   symbols or static symbols.  */
1430
 
1431
static struct symbol *
1432
lookup_symbol_aux_psymtabs (int block_index, const char *name,
1433
                            const char *linkage_name,
1434
                            const domain_enum domain,
1435
                            struct symtab **symtab)
1436
{
1437
  struct symbol *sym;
1438
  struct objfile *objfile;
1439
  struct blockvector *bv;
1440
  const struct block *block;
1441
  struct partial_symtab *ps;
1442
  struct symtab *s;
1443
  const int psymtab_index = (block_index == GLOBAL_BLOCK ? 1 : 0);
1444
 
1445
  ALL_PSYMTABS (objfile, ps)
1446
  {
1447
    if (!ps->readin
1448
        && lookup_partial_symbol (ps, name, linkage_name,
1449
                                  psymtab_index, domain))
1450
      {
1451
        s = PSYMTAB_TO_SYMTAB (ps);
1452
        bv = BLOCKVECTOR (s);
1453
        block = BLOCKVECTOR_BLOCK (bv, block_index);
1454
        sym = lookup_block_symbol (block, name, linkage_name, domain);
1455
        if (!sym)
1456
          {
1457
            /* This shouldn't be necessary, but as a last resort try
1458
               looking in the statics even though the psymtab claimed
1459
               the symbol was global, or vice-versa. It's possible
1460
               that the psymtab gets it wrong in some cases.  */
1461
 
1462
            /* FIXME: carlton/2002-09-30: Should we really do that?
1463
               If that happens, isn't it likely to be a GDB error, in
1464
               which case we should fix the GDB error rather than
1465
               silently dealing with it here?  So I'd vote for
1466
               removing the check for the symbol in the other
1467
               block.  */
1468
            block = BLOCKVECTOR_BLOCK (bv,
1469
                                       block_index == GLOBAL_BLOCK ?
1470
                                       STATIC_BLOCK : GLOBAL_BLOCK);
1471
            sym = lookup_block_symbol (block, name, linkage_name, domain);
1472
            if (!sym)
1473
              error (_("Internal: %s symbol `%s' found in %s psymtab but not in symtab.\n%s may be an inlined function, or may be a template function\n(if a template, try specifying an instantiation: %s<type>)."),
1474
                     block_index == GLOBAL_BLOCK ? "global" : "static",
1475
                     name, ps->filename, name, name);
1476
          }
1477
        if (symtab != NULL)
1478
          *symtab = s;
1479
        return fixup_symbol_section (sym, objfile);
1480
      }
1481
  }
1482
 
1483
  return NULL;
1484
}
1485
 
1486
/* A default version of lookup_symbol_nonlocal for use by languages
1487
   that can't think of anything better to do.  This implements the C
1488
   lookup rules.  */
1489
 
1490
struct symbol *
1491
basic_lookup_symbol_nonlocal (const char *name,
1492
                              const char *linkage_name,
1493
                              const struct block *block,
1494
                              const domain_enum domain,
1495
                              struct symtab **symtab)
1496
{
1497
  struct symbol *sym;
1498
 
1499
  /* NOTE: carlton/2003-05-19: The comments below were written when
1500
     this (or what turned into this) was part of lookup_symbol_aux;
1501
     I'm much less worried about these questions now, since these
1502
     decisions have turned out well, but I leave these comments here
1503
     for posterity.  */
1504
 
1505
  /* NOTE: carlton/2002-12-05: There is a question as to whether or
1506
     not it would be appropriate to search the current global block
1507
     here as well.  (That's what this code used to do before the
1508
     is_a_field_of_this check was moved up.)  On the one hand, it's
1509
     redundant with the lookup_symbol_aux_symtabs search that happens
1510
     next.  On the other hand, if decode_line_1 is passed an argument
1511
     like filename:var, then the user presumably wants 'var' to be
1512
     searched for in filename.  On the third hand, there shouldn't be
1513
     multiple global variables all of which are named 'var', and it's
1514
     not like decode_line_1 has ever restricted its search to only
1515
     global variables in a single filename.  All in all, only
1516
     searching the static block here seems best: it's correct and it's
1517
     cleanest.  */
1518
 
1519
  /* NOTE: carlton/2002-12-05: There's also a possible performance
1520
     issue here: if you usually search for global symbols in the
1521
     current file, then it would be slightly better to search the
1522
     current global block before searching all the symtabs.  But there
1523
     are other factors that have a much greater effect on performance
1524
     than that one, so I don't think we should worry about that for
1525
     now.  */
1526
 
1527
  sym = lookup_symbol_static (name, linkage_name, block, domain, symtab);
1528
  if (sym != NULL)
1529
    return sym;
1530
 
1531
  return lookup_symbol_global (name, linkage_name, block, domain, symtab);
1532
}
1533
 
1534
/* Lookup a symbol in the static block associated to BLOCK, if there
1535
   is one; do nothing if BLOCK is NULL or a global block.  */
1536
 
1537
struct symbol *
1538
lookup_symbol_static (const char *name,
1539
                      const char *linkage_name,
1540
                      const struct block *block,
1541
                      const domain_enum domain,
1542
                      struct symtab **symtab)
1543
{
1544
  const struct block *static_block = block_static_block (block);
1545
 
1546
  if (static_block != NULL)
1547
    return lookup_symbol_aux_block (name, linkage_name, static_block,
1548
                                    domain, symtab);
1549
  else
1550
    return NULL;
1551
}
1552
 
1553
/* Lookup a symbol in all files' global blocks (searching psymtabs if
1554
   necessary).  */
1555
 
1556
struct symbol *
1557
lookup_symbol_global (const char *name,
1558
                      const char *linkage_name,
1559
                      const struct block *block,
1560
                      const domain_enum domain,
1561
                      struct symtab **symtab)
1562
{
1563
  struct symbol *sym = NULL;
1564
  struct objfile *objfile = NULL;
1565
 
1566
  /* Call library-specific lookup procedure.  */
1567
  objfile = lookup_objfile_from_block (block);
1568
  if (objfile != NULL)
1569
    sym = solib_global_lookup (objfile, name, linkage_name, domain, symtab);
1570
  if (sym != NULL)
1571
    return sym;
1572
 
1573
  sym = lookup_symbol_aux_symtabs (GLOBAL_BLOCK, name, linkage_name,
1574
                                   domain, symtab);
1575
  if (sym != NULL)
1576
    return sym;
1577
 
1578
  return lookup_symbol_aux_psymtabs (GLOBAL_BLOCK, name, linkage_name,
1579
                                     domain, symtab);
1580
}
1581
 
1582
/* Look, in partial_symtab PST, for symbol whose natural name is NAME.
1583
   If LINKAGE_NAME is non-NULL, check in addition that the symbol's
1584
   linkage name matches it.  Check the global symbols if GLOBAL, the
1585
   static symbols if not */
1586
 
1587
struct partial_symbol *
1588
lookup_partial_symbol (struct partial_symtab *pst, const char *name,
1589
                       const char *linkage_name, int global,
1590
                       domain_enum domain)
1591
{
1592
  struct partial_symbol *temp;
1593
  struct partial_symbol **start, **psym;
1594
  struct partial_symbol **top, **real_top, **bottom, **center;
1595
  int length = (global ? pst->n_global_syms : pst->n_static_syms);
1596
  int do_linear_search = 1;
1597
 
1598
  if (length == 0)
1599
    {
1600
      return (NULL);
1601
    }
1602
  start = (global ?
1603
           pst->objfile->global_psymbols.list + pst->globals_offset :
1604
           pst->objfile->static_psymbols.list + pst->statics_offset);
1605
 
1606
  if (global)                   /* This means we can use a binary search. */
1607
    {
1608
      do_linear_search = 0;
1609
 
1610
      /* Binary search.  This search is guaranteed to end with center
1611
         pointing at the earliest partial symbol whose name might be
1612
         correct.  At that point *all* partial symbols with an
1613
         appropriate name will be checked against the correct
1614
         domain.  */
1615
 
1616
      bottom = start;
1617
      top = start + length - 1;
1618
      real_top = top;
1619
      while (top > bottom)
1620
        {
1621
          center = bottom + (top - bottom) / 2;
1622
          if (!(center < top))
1623
            internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
1624
          if (!do_linear_search
1625
              && (SYMBOL_LANGUAGE (*center) == language_java))
1626
            {
1627
              do_linear_search = 1;
1628
            }
1629
          if (strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*center), name) >= 0)
1630
            {
1631
              top = center;
1632
            }
1633
          else
1634
            {
1635
              bottom = center + 1;
1636
            }
1637
        }
1638
      if (!(top == bottom))
1639
        internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
1640
 
1641
      while (top <= real_top
1642
             && (linkage_name != NULL
1643
                 ? strcmp (SYMBOL_LINKAGE_NAME (*top), linkage_name) == 0
1644
                 : SYMBOL_MATCHES_SEARCH_NAME (*top,name)))
1645
        {
1646
          if (SYMBOL_DOMAIN (*top) == domain)
1647
            {
1648
                  return (*top);
1649
            }
1650
          top++;
1651
        }
1652
    }
1653
 
1654
  /* Can't use a binary search or else we found during the binary search that
1655
     we should also do a linear search. */
1656
 
1657
  if (do_linear_search)
1658
    {
1659
      for (psym = start; psym < start + length; psym++)
1660
        {
1661
          if (domain == SYMBOL_DOMAIN (*psym))
1662
            {
1663
              if (linkage_name != NULL
1664
                  ? strcmp (SYMBOL_LINKAGE_NAME (*psym), linkage_name) == 0
1665
                  : SYMBOL_MATCHES_SEARCH_NAME (*psym, name))
1666
                {
1667
                  return (*psym);
1668
                }
1669
            }
1670
        }
1671
    }
1672
 
1673
  return (NULL);
1674
}
1675
 
1676
/* Look up a type named NAME in the struct_domain.  The type returned
1677
   must not be opaque -- i.e., must have at least one field
1678
   defined.  */
1679
 
1680
struct type *
1681
lookup_transparent_type (const char *name)
1682
{
1683
  return current_language->la_lookup_transparent_type (name);
1684
}
1685
 
1686
/* The standard implementation of lookup_transparent_type.  This code
1687
   was modeled on lookup_symbol -- the parts not relevant to looking
1688
   up types were just left out.  In particular it's assumed here that
1689
   types are available in struct_domain and only at file-static or
1690
   global blocks.  */
1691
 
1692
struct type *
1693
basic_lookup_transparent_type (const char *name)
1694
{
1695
  struct symbol *sym;
1696
  struct symtab *s = NULL;
1697
  struct partial_symtab *ps;
1698
  struct blockvector *bv;
1699
  struct objfile *objfile;
1700
  struct block *block;
1701
 
1702
  /* Now search all the global symbols.  Do the symtab's first, then
1703
     check the psymtab's. If a psymtab indicates the existence
1704
     of the desired name as a global, then do psymtab-to-symtab
1705
     conversion on the fly and return the found symbol.  */
1706
 
1707
  ALL_PRIMARY_SYMTABS (objfile, s)
1708
  {
1709
    bv = BLOCKVECTOR (s);
1710
    block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1711
    sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN);
1712
    if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
1713
      {
1714
        return SYMBOL_TYPE (sym);
1715
      }
1716
  }
1717
 
1718
  ALL_PSYMTABS (objfile, ps)
1719
  {
1720
    if (!ps->readin && lookup_partial_symbol (ps, name, NULL,
1721
                                              1, STRUCT_DOMAIN))
1722
      {
1723
        s = PSYMTAB_TO_SYMTAB (ps);
1724
        bv = BLOCKVECTOR (s);
1725
        block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1726
        sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN);
1727
        if (!sym)
1728
          {
1729
            /* This shouldn't be necessary, but as a last resort
1730
             * try looking in the statics even though the psymtab
1731
             * claimed the symbol was global. It's possible that
1732
             * the psymtab gets it wrong in some cases.
1733
             */
1734
            block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
1735
            sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN);
1736
            if (!sym)
1737
              error (_("Internal: global symbol `%s' found in %s psymtab but not in symtab.\n\
1738
%s may be an inlined function, or may be a template function\n\
1739
(if a template, try specifying an instantiation: %s<type>)."),
1740
                     name, ps->filename, name, name);
1741
          }
1742
        if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
1743
          return SYMBOL_TYPE (sym);
1744
      }
1745
  }
1746
 
1747
  /* Now search the static file-level symbols.
1748
     Not strictly correct, but more useful than an error.
1749
     Do the symtab's first, then
1750
     check the psymtab's. If a psymtab indicates the existence
1751
     of the desired name as a file-level static, then do psymtab-to-symtab
1752
     conversion on the fly and return the found symbol.
1753
   */
1754
 
1755
  ALL_PRIMARY_SYMTABS (objfile, s)
1756
  {
1757
    bv = BLOCKVECTOR (s);
1758
    block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
1759
    sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN);
1760
    if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
1761
      {
1762
        return SYMBOL_TYPE (sym);
1763
      }
1764
  }
1765
 
1766
  ALL_PSYMTABS (objfile, ps)
1767
  {
1768
    if (!ps->readin && lookup_partial_symbol (ps, name, NULL, 0, STRUCT_DOMAIN))
1769
      {
1770
        s = PSYMTAB_TO_SYMTAB (ps);
1771
        bv = BLOCKVECTOR (s);
1772
        block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
1773
        sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN);
1774
        if (!sym)
1775
          {
1776
            /* This shouldn't be necessary, but as a last resort
1777
             * try looking in the globals even though the psymtab
1778
             * claimed the symbol was static. It's possible that
1779
             * the psymtab gets it wrong in some cases.
1780
             */
1781
            block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1782
            sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN);
1783
            if (!sym)
1784
              error (_("Internal: static symbol `%s' found in %s psymtab but not in symtab.\n\
1785
%s may be an inlined function, or may be a template function\n\
1786
(if a template, try specifying an instantiation: %s<type>)."),
1787
                     name, ps->filename, name, name);
1788
          }
1789
        if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
1790
          return SYMBOL_TYPE (sym);
1791
      }
1792
  }
1793
  return (struct type *) 0;
1794
}
1795
 
1796
 
1797
/* Find the psymtab containing main(). */
1798
/* FIXME:  What about languages without main() or specially linked
1799
   executables that have no main() ? */
1800
 
1801
struct partial_symtab *
1802
find_main_psymtab (void)
1803
{
1804
  struct partial_symtab *pst;
1805
  struct objfile *objfile;
1806
 
1807
  ALL_PSYMTABS (objfile, pst)
1808
  {
1809
    if (lookup_partial_symbol (pst, main_name (), NULL, 1, VAR_DOMAIN))
1810
      {
1811
        return (pst);
1812
      }
1813
  }
1814
  return (NULL);
1815
}
1816
 
1817
/* Search BLOCK for symbol NAME in DOMAIN.
1818
 
1819
   Note that if NAME is the demangled form of a C++ symbol, we will fail
1820
   to find a match during the binary search of the non-encoded names, but
1821
   for now we don't worry about the slight inefficiency of looking for
1822
   a match we'll never find, since it will go pretty quick.  Once the
1823
   binary search terminates, we drop through and do a straight linear
1824
   search on the symbols.  Each symbol which is marked as being a ObjC/C++
1825
   symbol (language_cplus or language_objc set) has both the encoded and
1826
   non-encoded names tested for a match.
1827
 
1828
   If LINKAGE_NAME is non-NULL, verify that any symbol we find has this
1829
   particular mangled name.
1830
*/
1831
 
1832
struct symbol *
1833
lookup_block_symbol (const struct block *block, const char *name,
1834
                     const char *linkage_name,
1835
                     const domain_enum domain)
1836
{
1837
  struct dict_iterator iter;
1838
  struct symbol *sym;
1839
 
1840
  if (!BLOCK_FUNCTION (block))
1841
    {
1842
      for (sym = dict_iter_name_first (BLOCK_DICT (block), name, &iter);
1843
           sym != NULL;
1844
           sym = dict_iter_name_next (name, &iter))
1845
        {
1846
          if (SYMBOL_DOMAIN (sym) == domain
1847
              && (linkage_name != NULL
1848
                  ? strcmp (SYMBOL_LINKAGE_NAME (sym), linkage_name) == 0 : 1))
1849
            return sym;
1850
        }
1851
      return NULL;
1852
    }
1853
  else
1854
    {
1855
      /* Note that parameter symbols do not always show up last in the
1856
         list; this loop makes sure to take anything else other than
1857
         parameter symbols first; it only uses parameter symbols as a
1858
         last resort.  Note that this only takes up extra computation
1859
         time on a match.  */
1860
 
1861
      struct symbol *sym_found = NULL;
1862
 
1863
      for (sym = dict_iter_name_first (BLOCK_DICT (block), name, &iter);
1864
           sym != NULL;
1865
           sym = dict_iter_name_next (name, &iter))
1866
        {
1867
          if (SYMBOL_DOMAIN (sym) == domain
1868
              && (linkage_name != NULL
1869
                  ? strcmp (SYMBOL_LINKAGE_NAME (sym), linkage_name) == 0 : 1))
1870
            {
1871
              sym_found = sym;
1872
              if (SYMBOL_CLASS (sym) != LOC_ARG &&
1873
                  SYMBOL_CLASS (sym) != LOC_LOCAL_ARG &&
1874
                  SYMBOL_CLASS (sym) != LOC_REF_ARG &&
1875
                  SYMBOL_CLASS (sym) != LOC_REGPARM &&
1876
                  SYMBOL_CLASS (sym) != LOC_REGPARM_ADDR &&
1877
                  SYMBOL_CLASS (sym) != LOC_BASEREG_ARG &&
1878
                  SYMBOL_CLASS (sym) != LOC_COMPUTED_ARG)
1879
                {
1880
                  break;
1881
                }
1882
            }
1883
        }
1884
      return (sym_found);       /* Will be NULL if not found. */
1885
    }
1886
}
1887
 
1888
/* Find the symtab associated with PC and SECTION.  Look through the
1889
   psymtabs and read in another symtab if necessary. */
1890
 
1891
struct symtab *
1892
find_pc_sect_symtab (CORE_ADDR pc, asection *section)
1893
{
1894
  struct block *b;
1895
  struct blockvector *bv;
1896
  struct symtab *s = NULL;
1897
  struct symtab *best_s = NULL;
1898
  struct partial_symtab *ps;
1899
  struct objfile *objfile;
1900
  CORE_ADDR distance = 0;
1901
  struct minimal_symbol *msymbol;
1902
 
1903
  /* If we know that this is not a text address, return failure.  This is
1904
     necessary because we loop based on the block's high and low code
1905
     addresses, which do not include the data ranges, and because
1906
     we call find_pc_sect_psymtab which has a similar restriction based
1907
     on the partial_symtab's texthigh and textlow.  */
1908
  msymbol = lookup_minimal_symbol_by_pc_section (pc, section);
1909
  if (msymbol
1910
      && (msymbol->type == mst_data
1911
          || msymbol->type == mst_bss
1912
          || msymbol->type == mst_abs
1913
          || msymbol->type == mst_file_data
1914
          || msymbol->type == mst_file_bss))
1915
    return NULL;
1916
 
1917
  /* Search all symtabs for the one whose file contains our address, and which
1918
     is the smallest of all the ones containing the address.  This is designed
1919
     to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
1920
     and symtab b is at 0x2000-0x3000.  So the GLOBAL_BLOCK for a is from
1921
     0x1000-0x4000, but for address 0x2345 we want to return symtab b.
1922
 
1923
     This happens for native ecoff format, where code from included files
1924
     gets its own symtab. The symtab for the included file should have
1925
     been read in already via the dependency mechanism.
1926
     It might be swifter to create several symtabs with the same name
1927
     like xcoff does (I'm not sure).
1928
 
1929
     It also happens for objfiles that have their functions reordered.
1930
     For these, the symtab we are looking for is not necessarily read in.  */
1931
 
1932
  ALL_PRIMARY_SYMTABS (objfile, s)
1933
  {
1934
    bv = BLOCKVECTOR (s);
1935
    b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1936
 
1937
    if (BLOCK_START (b) <= pc
1938
        && BLOCK_END (b) > pc
1939
        && (distance == 0
1940
            || BLOCK_END (b) - BLOCK_START (b) < distance))
1941
      {
1942
        /* For an objfile that has its functions reordered,
1943
           find_pc_psymtab will find the proper partial symbol table
1944
           and we simply return its corresponding symtab.  */
1945
        /* In order to better support objfiles that contain both
1946
           stabs and coff debugging info, we continue on if a psymtab
1947
           can't be found. */
1948
        if ((objfile->flags & OBJF_REORDERED) && objfile->psymtabs)
1949
          {
1950
            ps = find_pc_sect_psymtab (pc, section);
1951
            if (ps)
1952
              return PSYMTAB_TO_SYMTAB (ps);
1953
          }
1954
        if (section != 0)
1955
          {
1956
            struct dict_iterator iter;
1957
            struct symbol *sym = NULL;
1958
 
1959
            ALL_BLOCK_SYMBOLS (b, iter, sym)
1960
              {
1961
                fixup_symbol_section (sym, objfile);
1962
                if (matching_bfd_sections (SYMBOL_BFD_SECTION (sym), section))
1963
                  break;
1964
              }
1965
            if (sym == NULL)
1966
              continue;         /* no symbol in this symtab matches section */
1967
          }
1968
        distance = BLOCK_END (b) - BLOCK_START (b);
1969
        best_s = s;
1970
      }
1971
  }
1972
 
1973
  if (best_s != NULL)
1974
    return (best_s);
1975
 
1976
  s = NULL;
1977
  ps = find_pc_sect_psymtab (pc, section);
1978
  if (ps)
1979
    {
1980
      if (ps->readin)
1981
        /* Might want to error() here (in case symtab is corrupt and
1982
           will cause a core dump), but maybe we can successfully
1983
           continue, so let's not.  */
1984
        warning (_("\
1985
(Internal error: pc 0x%s in read in psymtab, but not in symtab.)\n"),
1986
                 paddr_nz (pc));
1987
      s = PSYMTAB_TO_SYMTAB (ps);
1988
    }
1989
  return (s);
1990
}
1991
 
1992
/* Find the symtab associated with PC.  Look through the psymtabs and
1993
   read in another symtab if necessary.  Backward compatibility, no section */
1994
 
1995
struct symtab *
1996
find_pc_symtab (CORE_ADDR pc)
1997
{
1998
  return find_pc_sect_symtab (pc, find_pc_mapped_section (pc));
1999
}
2000
 
2001
 
2002
/* Find the source file and line number for a given PC value and SECTION.
2003
   Return a structure containing a symtab pointer, a line number,
2004
   and a pc range for the entire source line.
2005
   The value's .pc field is NOT the specified pc.
2006
   NOTCURRENT nonzero means, if specified pc is on a line boundary,
2007
   use the line that ends there.  Otherwise, in that case, the line
2008
   that begins there is used.  */
2009
 
2010
/* The big complication here is that a line may start in one file, and end just
2011
   before the start of another file.  This usually occurs when you #include
2012
   code in the middle of a subroutine.  To properly find the end of a line's PC
2013
   range, we must search all symtabs associated with this compilation unit, and
2014
   find the one whose first PC is closer than that of the next line in this
2015
   symtab.  */
2016
 
2017
/* If it's worth the effort, we could be using a binary search.  */
2018
 
2019
struct symtab_and_line
2020
find_pc_sect_line (CORE_ADDR pc, struct bfd_section *section, int notcurrent)
2021
{
2022
  struct symtab *s;
2023
  struct linetable *l;
2024
  int len;
2025
  int i;
2026
  struct linetable_entry *item;
2027
  struct symtab_and_line val;
2028
  struct blockvector *bv;
2029
  struct minimal_symbol *msymbol;
2030
  struct minimal_symbol *mfunsym;
2031
 
2032
  /* Info on best line seen so far, and where it starts, and its file.  */
2033
 
2034
  struct linetable_entry *best = NULL;
2035
  CORE_ADDR best_end = 0;
2036
  struct symtab *best_symtab = 0;
2037
 
2038
  /* Store here the first line number
2039
     of a file which contains the line at the smallest pc after PC.
2040
     If we don't find a line whose range contains PC,
2041
     we will use a line one less than this,
2042
     with a range from the start of that file to the first line's pc.  */
2043
  struct linetable_entry *alt = NULL;
2044
  struct symtab *alt_symtab = 0;
2045
 
2046
  /* Info on best line seen in this file.  */
2047
 
2048
  struct linetable_entry *prev;
2049
 
2050
  /* If this pc is not from the current frame,
2051
     it is the address of the end of a call instruction.
2052
     Quite likely that is the start of the following statement.
2053
     But what we want is the statement containing the instruction.
2054
     Fudge the pc to make sure we get that.  */
2055
 
2056
  init_sal (&val);              /* initialize to zeroes */
2057
 
2058
  /* It's tempting to assume that, if we can't find debugging info for
2059
     any function enclosing PC, that we shouldn't search for line
2060
     number info, either.  However, GAS can emit line number info for
2061
     assembly files --- very helpful when debugging hand-written
2062
     assembly code.  In such a case, we'd have no debug info for the
2063
     function, but we would have line info.  */
2064
 
2065
  if (notcurrent)
2066
    pc -= 1;
2067
 
2068
  /* elz: added this because this function returned the wrong
2069
     information if the pc belongs to a stub (import/export)
2070
     to call a shlib function. This stub would be anywhere between
2071
     two functions in the target, and the line info was erroneously
2072
     taken to be the one of the line before the pc.
2073
   */
2074
  /* RT: Further explanation:
2075
 
2076
   * We have stubs (trampolines) inserted between procedures.
2077
   *
2078
   * Example: "shr1" exists in a shared library, and a "shr1" stub also
2079
   * exists in the main image.
2080
   *
2081
   * In the minimal symbol table, we have a bunch of symbols
2082
   * sorted by start address. The stubs are marked as "trampoline",
2083
   * the others appear as text. E.g.:
2084
   *
2085
   *  Minimal symbol table for main image
2086
   *     main:  code for main (text symbol)
2087
   *     shr1: stub  (trampoline symbol)
2088
   *     foo:   code for foo (text symbol)
2089
   *     ...
2090
   *  Minimal symbol table for "shr1" image:
2091
   *     ...
2092
   *     shr1: code for shr1 (text symbol)
2093
   *     ...
2094
   *
2095
   * So the code below is trying to detect if we are in the stub
2096
   * ("shr1" stub), and if so, find the real code ("shr1" trampoline),
2097
   * and if found,  do the symbolization from the real-code address
2098
   * rather than the stub address.
2099
   *
2100
   * Assumptions being made about the minimal symbol table:
2101
   *   1. lookup_minimal_symbol_by_pc() will return a trampoline only
2102
   *      if we're really in the trampoline. If we're beyond it (say
2103
   *      we're in "foo" in the above example), it'll have a closer
2104
   *      symbol (the "foo" text symbol for example) and will not
2105
   *      return the trampoline.
2106
   *   2. lookup_minimal_symbol_text() will find a real text symbol
2107
   *      corresponding to the trampoline, and whose address will
2108
   *      be different than the trampoline address. I put in a sanity
2109
   *      check for the address being the same, to avoid an
2110
   *      infinite recursion.
2111
   */
2112
  msymbol = lookup_minimal_symbol_by_pc (pc);
2113
  if (msymbol != NULL)
2114
    if (MSYMBOL_TYPE (msymbol) == mst_solib_trampoline)
2115
      {
2116
        mfunsym = lookup_minimal_symbol_text (SYMBOL_LINKAGE_NAME (msymbol),
2117
                                              NULL);
2118
        if (mfunsym == NULL)
2119
          /* I eliminated this warning since it is coming out
2120
           * in the following situation:
2121
           * gdb shmain // test program with shared libraries
2122
           * (gdb) break shr1  // function in shared lib
2123
           * Warning: In stub for ...
2124
           * In the above situation, the shared lib is not loaded yet,
2125
           * so of course we can't find the real func/line info,
2126
           * but the "break" still works, and the warning is annoying.
2127
           * So I commented out the warning. RT */
2128
          /* warning ("In stub for %s; unable to find real function/line info", SYMBOL_LINKAGE_NAME (msymbol)) */ ;
2129
        /* fall through */
2130
        else if (SYMBOL_VALUE_ADDRESS (mfunsym) == SYMBOL_VALUE_ADDRESS (msymbol))
2131
          /* Avoid infinite recursion */
2132
          /* See above comment about why warning is commented out */
2133
          /* warning ("In stub for %s; unable to find real function/line info", SYMBOL_LINKAGE_NAME (msymbol)) */ ;
2134
        /* fall through */
2135
        else
2136
          return find_pc_line (SYMBOL_VALUE_ADDRESS (mfunsym), 0);
2137
      }
2138
 
2139
 
2140
  s = find_pc_sect_symtab (pc, section);
2141
  if (!s)
2142
    {
2143
      /* if no symbol information, return previous pc */
2144
      if (notcurrent)
2145
        pc++;
2146
      val.pc = pc;
2147
      return val;
2148
    }
2149
 
2150
  bv = BLOCKVECTOR (s);
2151
 
2152
  /* Look at all the symtabs that share this blockvector.
2153
     They all have the same apriori range, that we found was right;
2154
     but they have different line tables.  */
2155
 
2156
  for (; s && BLOCKVECTOR (s) == bv; s = s->next)
2157
    {
2158
      /* Find the best line in this symtab.  */
2159
      l = LINETABLE (s);
2160
      if (!l)
2161
        continue;
2162
      len = l->nitems;
2163
      if (len <= 0)
2164
        {
2165
          /* I think len can be zero if the symtab lacks line numbers
2166
             (e.g. gcc -g1).  (Either that or the LINETABLE is NULL;
2167
             I'm not sure which, and maybe it depends on the symbol
2168
             reader).  */
2169
          continue;
2170
        }
2171
 
2172
      prev = NULL;
2173
      item = l->item;           /* Get first line info */
2174
 
2175
      /* Is this file's first line closer than the first lines of other files?
2176
         If so, record this file, and its first line, as best alternate.  */
2177
      if (item->pc > pc && (!alt || item->pc < alt->pc))
2178
        {
2179
          alt = item;
2180
          alt_symtab = s;
2181
        }
2182
 
2183
      for (i = 0; i < len; i++, item++)
2184
        {
2185
          /* Leave prev pointing to the linetable entry for the last line
2186
             that started at or before PC.  */
2187
          if (item->pc > pc)
2188
            break;
2189
 
2190
          prev = item;
2191
        }
2192
 
2193
      /* At this point, prev points at the line whose start addr is <= pc, and
2194
         item points at the next line.  If we ran off the end of the linetable
2195
         (pc >= start of the last line), then prev == item.  If pc < start of
2196
         the first line, prev will not be set.  */
2197
 
2198
      /* Is this file's best line closer than the best in the other files?
2199
         If so, record this file, and its best line, as best so far.  Don't
2200
         save prev if it represents the end of a function (i.e. line number
2201
         0) instead of a real line.  */
2202
 
2203
      if (prev && prev->line && (!best || prev->pc > best->pc))
2204
        {
2205
          best = prev;
2206
          best_symtab = s;
2207
 
2208
          /* Discard BEST_END if it's before the PC of the current BEST.  */
2209
          if (best_end <= best->pc)
2210
            best_end = 0;
2211
        }
2212
 
2213
      /* If another line (denoted by ITEM) is in the linetable and its
2214
         PC is after BEST's PC, but before the current BEST_END, then
2215
         use ITEM's PC as the new best_end.  */
2216
      if (best && i < len && item->pc > best->pc
2217
          && (best_end == 0 || best_end > item->pc))
2218
        best_end = item->pc;
2219
    }
2220
 
2221
  if (!best_symtab)
2222
    {
2223
      /* If we didn't find any line number info, just return zeros.
2224
         We used to return alt->line - 1 here, but that could be
2225
         anywhere; if we don't have line number info for this PC,
2226
         don't make some up.  */
2227
      val.pc = pc;
2228
    }
2229
  else if (best->line == 0)
2230
    {
2231
      /* If our best fit is in a range of PC's for which no line
2232
         number info is available (line number is zero) then we didn't
2233
         find any valid line information. */
2234
      val.pc = pc;
2235
    }
2236
  else
2237
    {
2238
      val.symtab = best_symtab;
2239
      val.line = best->line;
2240
      val.pc = best->pc;
2241
      if (best_end && (!alt || best_end < alt->pc))
2242
        val.end = best_end;
2243
      else if (alt)
2244
        val.end = alt->pc;
2245
      else
2246
        val.end = BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
2247
    }
2248
  val.section = section;
2249
  return val;
2250
}
2251
 
2252
/* Backward compatibility (no section) */
2253
 
2254
struct symtab_and_line
2255
find_pc_line (CORE_ADDR pc, int notcurrent)
2256
{
2257
  asection *section;
2258
 
2259
  section = find_pc_overlay (pc);
2260
  if (pc_in_unmapped_range (pc, section))
2261
    pc = overlay_mapped_address (pc, section);
2262
  return find_pc_sect_line (pc, section, notcurrent);
2263
}
2264
 
2265
/* Find line number LINE in any symtab whose name is the same as
2266
   SYMTAB.
2267
 
2268
   If found, return the symtab that contains the linetable in which it was
2269
   found, set *INDEX to the index in the linetable of the best entry
2270
   found, and set *EXACT_MATCH nonzero if the value returned is an
2271
   exact match.
2272
 
2273
   If not found, return NULL.  */
2274
 
2275
struct symtab *
2276
find_line_symtab (struct symtab *symtab, int line, int *index, int *exact_match)
2277
{
2278
  int exact;
2279
 
2280
  /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
2281
     so far seen.  */
2282
 
2283
  int best_index;
2284
  struct linetable *best_linetable;
2285
  struct symtab *best_symtab;
2286
 
2287
  /* First try looking it up in the given symtab.  */
2288
  best_linetable = LINETABLE (symtab);
2289
  best_symtab = symtab;
2290
  best_index = find_line_common (best_linetable, line, &exact);
2291
  if (best_index < 0 || !exact)
2292
    {
2293
      /* Didn't find an exact match.  So we better keep looking for
2294
         another symtab with the same name.  In the case of xcoff,
2295
         multiple csects for one source file (produced by IBM's FORTRAN
2296
         compiler) produce multiple symtabs (this is unavoidable
2297
         assuming csects can be at arbitrary places in memory and that
2298
         the GLOBAL_BLOCK of a symtab has a begin and end address).  */
2299
 
2300
      /* BEST is the smallest linenumber > LINE so far seen,
2301
         or 0 if none has been seen so far.
2302
         BEST_INDEX and BEST_LINETABLE identify the item for it.  */
2303
      int best;
2304
 
2305
      struct objfile *objfile;
2306
      struct symtab *s;
2307
      struct partial_symtab *p;
2308
 
2309
      if (best_index >= 0)
2310
        best = best_linetable->item[best_index].line;
2311
      else
2312
        best = 0;
2313
 
2314
      ALL_PSYMTABS (objfile, p)
2315
      {
2316
        if (strcmp (symtab->filename, p->filename) != 0)
2317
          continue;
2318
        PSYMTAB_TO_SYMTAB (p);
2319
      }
2320
 
2321
      ALL_SYMTABS (objfile, s)
2322
      {
2323
        struct linetable *l;
2324
        int ind;
2325
 
2326
        if (strcmp (symtab->filename, s->filename) != 0)
2327
          continue;
2328
        l = LINETABLE (s);
2329
        ind = find_line_common (l, line, &exact);
2330
        if (ind >= 0)
2331
          {
2332
            if (exact)
2333
              {
2334
                best_index = ind;
2335
                best_linetable = l;
2336
                best_symtab = s;
2337
                goto done;
2338
              }
2339
            if (best == 0 || l->item[ind].line < best)
2340
              {
2341
                best = l->item[ind].line;
2342
                best_index = ind;
2343
                best_linetable = l;
2344
                best_symtab = s;
2345
              }
2346
          }
2347
      }
2348
    }
2349
done:
2350
  if (best_index < 0)
2351
    return NULL;
2352
 
2353
  if (index)
2354
    *index = best_index;
2355
  if (exact_match)
2356
    *exact_match = exact;
2357
 
2358
  return best_symtab;
2359
}
2360
 
2361
/* Set the PC value for a given source file and line number and return true.
2362
   Returns zero for invalid line number (and sets the PC to 0).
2363
   The source file is specified with a struct symtab.  */
2364
 
2365
int
2366
find_line_pc (struct symtab *symtab, int line, CORE_ADDR *pc)
2367
{
2368
  struct linetable *l;
2369
  int ind;
2370
 
2371
  *pc = 0;
2372
  if (symtab == 0)
2373
    return 0;
2374
 
2375
  symtab = find_line_symtab (symtab, line, &ind, NULL);
2376
  if (symtab != NULL)
2377
    {
2378
      l = LINETABLE (symtab);
2379
      *pc = l->item[ind].pc;
2380
      return 1;
2381
    }
2382
  else
2383
    return 0;
2384
}
2385
 
2386
/* Find the range of pc values in a line.
2387
   Store the starting pc of the line into *STARTPTR
2388
   and the ending pc (start of next line) into *ENDPTR.
2389
   Returns 1 to indicate success.
2390
   Returns 0 if could not find the specified line.  */
2391
 
2392
int
2393
find_line_pc_range (struct symtab_and_line sal, CORE_ADDR *startptr,
2394
                    CORE_ADDR *endptr)
2395
{
2396
  CORE_ADDR startaddr;
2397
  struct symtab_and_line found_sal;
2398
 
2399
  startaddr = sal.pc;
2400
  if (startaddr == 0 && !find_line_pc (sal.symtab, sal.line, &startaddr))
2401
    return 0;
2402
 
2403
  /* This whole function is based on address.  For example, if line 10 has
2404
     two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
2405
     "info line *0x123" should say the line goes from 0x100 to 0x200
2406
     and "info line *0x355" should say the line goes from 0x300 to 0x400.
2407
     This also insures that we never give a range like "starts at 0x134
2408
     and ends at 0x12c".  */
2409
 
2410
  found_sal = find_pc_sect_line (startaddr, sal.section, 0);
2411
  if (found_sal.line != sal.line)
2412
    {
2413
      /* The specified line (sal) has zero bytes.  */
2414
      *startptr = found_sal.pc;
2415
      *endptr = found_sal.pc;
2416
    }
2417
  else
2418
    {
2419
      *startptr = found_sal.pc;
2420
      *endptr = found_sal.end;
2421
    }
2422
  return 1;
2423
}
2424
 
2425
/* Given a line table and a line number, return the index into the line
2426
   table for the pc of the nearest line whose number is >= the specified one.
2427
   Return -1 if none is found.  The value is >= 0 if it is an index.
2428
 
2429
   Set *EXACT_MATCH nonzero if the value returned is an exact match.  */
2430
 
2431
static int
2432
find_line_common (struct linetable *l, int lineno,
2433
                  int *exact_match)
2434
{
2435
  int i;
2436
  int len;
2437
 
2438
  /* BEST is the smallest linenumber > LINENO so far seen,
2439
     or 0 if none has been seen so far.
2440
     BEST_INDEX identifies the item for it.  */
2441
 
2442
  int best_index = -1;
2443
  int best = 0;
2444
 
2445
  *exact_match = 0;
2446
 
2447
  if (lineno <= 0)
2448
    return -1;
2449
  if (l == 0)
2450
    return -1;
2451
 
2452
  len = l->nitems;
2453
  for (i = 0; i < len; i++)
2454
    {
2455
      struct linetable_entry *item = &(l->item[i]);
2456
 
2457
      if (item->line == lineno)
2458
        {
2459
          /* Return the first (lowest address) entry which matches.  */
2460
          *exact_match = 1;
2461
          return i;
2462
        }
2463
 
2464
      if (item->line > lineno && (best == 0 || item->line < best))
2465
        {
2466
          best = item->line;
2467
          best_index = i;
2468
        }
2469
    }
2470
 
2471
  /* If we got here, we didn't get an exact match.  */
2472
  return best_index;
2473
}
2474
 
2475
int
2476
find_pc_line_pc_range (CORE_ADDR pc, CORE_ADDR *startptr, CORE_ADDR *endptr)
2477
{
2478
  struct symtab_and_line sal;
2479
  sal = find_pc_line (pc, 0);
2480
  *startptr = sal.pc;
2481
  *endptr = sal.end;
2482
  return sal.symtab != 0;
2483
}
2484
 
2485
/* Given a function symbol SYM, find the symtab and line for the start
2486
   of the function.
2487
   If the argument FUNFIRSTLINE is nonzero, we want the first line
2488
   of real code inside the function.  */
2489
 
2490
struct symtab_and_line
2491
find_function_start_sal (struct symbol *sym, int funfirstline)
2492
{
2493
  CORE_ADDR pc;
2494
  struct symtab_and_line sal;
2495
 
2496
  pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
2497
  fixup_symbol_section (sym, NULL);
2498
  if (funfirstline)
2499
    {                           /* skip "first line" of function (which is actually its prologue) */
2500
      asection *section = SYMBOL_BFD_SECTION (sym);
2501
      /* If function is in an unmapped overlay, use its unmapped LMA
2502
         address, so that gdbarch_skip_prologue has something unique to work
2503
         on */
2504
      if (section_is_overlay (section) &&
2505
          !section_is_mapped (section))
2506
        pc = overlay_unmapped_address (pc, section);
2507
 
2508
      pc += gdbarch_deprecated_function_start_offset (current_gdbarch);
2509
      pc = gdbarch_skip_prologue (current_gdbarch, pc);
2510
 
2511
      /* For overlays, map pc back into its mapped VMA range */
2512
      pc = overlay_mapped_address (pc, section);
2513
    }
2514
  sal = find_pc_sect_line (pc, SYMBOL_BFD_SECTION (sym), 0);
2515
 
2516
  /* Check if gdbarch_skip_prologue left us in mid-line, and the next
2517
     line is still part of the same function.  */
2518
  if (sal.pc != pc
2519
      && BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) <= sal.end
2520
      && sal.end < BLOCK_END (SYMBOL_BLOCK_VALUE (sym)))
2521
    {
2522
      /* First pc of next line */
2523
      pc = sal.end;
2524
      /* Recalculate the line number (might not be N+1).  */
2525
      sal = find_pc_sect_line (pc, SYMBOL_BFD_SECTION (sym), 0);
2526
    }
2527
  sal.pc = pc;
2528
 
2529
  return sal;
2530
}
2531
 
2532
/* If P is of the form "operator[ \t]+..." where `...' is
2533
   some legitimate operator text, return a pointer to the
2534
   beginning of the substring of the operator text.
2535
   Otherwise, return "".  */
2536
char *
2537
operator_chars (char *p, char **end)
2538
{
2539
  *end = "";
2540
  if (strncmp (p, "operator", 8))
2541
    return *end;
2542
  p += 8;
2543
 
2544
  /* Don't get faked out by `operator' being part of a longer
2545
     identifier.  */
2546
  if (isalpha (*p) || *p == '_' || *p == '$' || *p == '\0')
2547
    return *end;
2548
 
2549
  /* Allow some whitespace between `operator' and the operator symbol.  */
2550
  while (*p == ' ' || *p == '\t')
2551
    p++;
2552
 
2553
  /* Recognize 'operator TYPENAME'. */
2554
 
2555
  if (isalpha (*p) || *p == '_' || *p == '$')
2556
    {
2557
      char *q = p + 1;
2558
      while (isalnum (*q) || *q == '_' || *q == '$')
2559
        q++;
2560
      *end = q;
2561
      return p;
2562
    }
2563
 
2564
  while (*p)
2565
    switch (*p)
2566
      {
2567
      case '\\':                        /* regexp quoting */
2568
        if (p[1] == '*')
2569
          {
2570
            if (p[2] == '=')    /* 'operator\*=' */
2571
              *end = p + 3;
2572
            else                        /* 'operator\*'  */
2573
              *end = p + 2;
2574
            return p;
2575
          }
2576
        else if (p[1] == '[')
2577
          {
2578
            if (p[2] == ']')
2579
              error (_("mismatched quoting on brackets, try 'operator\\[\\]'"));
2580
            else if (p[2] == '\\' && p[3] == ']')
2581
              {
2582
                *end = p + 4;   /* 'operator\[\]' */
2583
                return p;
2584
              }
2585
            else
2586
              error (_("nothing is allowed between '[' and ']'"));
2587
          }
2588
        else
2589
          {
2590
            /* Gratuitous qoute: skip it and move on. */
2591
            p++;
2592
            continue;
2593
          }
2594
        break;
2595
      case '!':
2596
      case '=':
2597
      case '*':
2598
      case '/':
2599
      case '%':
2600
      case '^':
2601
        if (p[1] == '=')
2602
          *end = p + 2;
2603
        else
2604
          *end = p + 1;
2605
        return p;
2606
      case '<':
2607
      case '>':
2608
      case '+':
2609
      case '-':
2610
      case '&':
2611
      case '|':
2612
        if (p[0] == '-' && p[1] == '>')
2613
          {
2614
            /* Struct pointer member operator 'operator->'. */
2615
            if (p[2] == '*')
2616
              {
2617
                *end = p + 3;   /* 'operator->*' */
2618
                return p;
2619
              }
2620
            else if (p[2] == '\\')
2621
              {
2622
                *end = p + 4;   /* Hopefully 'operator->\*' */
2623
                return p;
2624
              }
2625
            else
2626
              {
2627
                *end = p + 2;   /* 'operator->' */
2628
                return p;
2629
              }
2630
          }
2631
        if (p[1] == '=' || p[1] == p[0])
2632
          *end = p + 2;
2633
        else
2634
          *end = p + 1;
2635
        return p;
2636
      case '~':
2637
      case ',':
2638
        *end = p + 1;
2639
        return p;
2640
      case '(':
2641
        if (p[1] != ')')
2642
          error (_("`operator ()' must be specified without whitespace in `()'"));
2643
        *end = p + 2;
2644
        return p;
2645
      case '?':
2646
        if (p[1] != ':')
2647
          error (_("`operator ?:' must be specified without whitespace in `?:'"));
2648
        *end = p + 2;
2649
        return p;
2650
      case '[':
2651
        if (p[1] != ']')
2652
          error (_("`operator []' must be specified without whitespace in `[]'"));
2653
        *end = p + 2;
2654
        return p;
2655
      default:
2656
        error (_("`operator %s' not supported"), p);
2657
        break;
2658
      }
2659
 
2660
  *end = "";
2661
  return *end;
2662
}
2663
 
2664
 
2665
/* If FILE is not already in the table of files, return zero;
2666
   otherwise return non-zero.  Optionally add FILE to the table if ADD
2667
   is non-zero.  If *FIRST is non-zero, forget the old table
2668
   contents.  */
2669
static int
2670
filename_seen (const char *file, int add, int *first)
2671
{
2672
  /* Table of files seen so far.  */
2673
  static const char **tab = NULL;
2674
  /* Allocated size of tab in elements.
2675
     Start with one 256-byte block (when using GNU malloc.c).
2676
     24 is the malloc overhead when range checking is in effect.  */
2677
  static int tab_alloc_size = (256 - 24) / sizeof (char *);
2678
  /* Current size of tab in elements.  */
2679
  static int tab_cur_size;
2680
  const char **p;
2681
 
2682
  if (*first)
2683
    {
2684
      if (tab == NULL)
2685
        tab = (const char **) xmalloc (tab_alloc_size * sizeof (*tab));
2686
      tab_cur_size = 0;
2687
    }
2688
 
2689
  /* Is FILE in tab?  */
2690
  for (p = tab; p < tab + tab_cur_size; p++)
2691
    if (strcmp (*p, file) == 0)
2692
      return 1;
2693
 
2694
  /* No; maybe add it to tab.  */
2695
  if (add)
2696
    {
2697
      if (tab_cur_size == tab_alloc_size)
2698
        {
2699
          tab_alloc_size *= 2;
2700
          tab = (const char **) xrealloc ((char *) tab,
2701
                                          tab_alloc_size * sizeof (*tab));
2702
        }
2703
      tab[tab_cur_size++] = file;
2704
    }
2705
 
2706
  return 0;
2707
}
2708
 
2709
/* Slave routine for sources_info.  Force line breaks at ,'s.
2710
   NAME is the name to print and *FIRST is nonzero if this is the first
2711
   name printed.  Set *FIRST to zero.  */
2712
static void
2713
output_source_filename (const char *name, int *first)
2714
{
2715
  /* Since a single source file can result in several partial symbol
2716
     tables, we need to avoid printing it more than once.  Note: if
2717
     some of the psymtabs are read in and some are not, it gets
2718
     printed both under "Source files for which symbols have been
2719
     read" and "Source files for which symbols will be read in on
2720
     demand".  I consider this a reasonable way to deal with the
2721
     situation.  I'm not sure whether this can also happen for
2722
     symtabs; it doesn't hurt to check.  */
2723
 
2724
  /* Was NAME already seen?  */
2725
  if (filename_seen (name, 1, first))
2726
    {
2727
      /* Yes; don't print it again.  */
2728
      return;
2729
    }
2730
  /* No; print it and reset *FIRST.  */
2731
  if (*first)
2732
    {
2733
      *first = 0;
2734
    }
2735
  else
2736
    {
2737
      printf_filtered (", ");
2738
    }
2739
 
2740
  wrap_here ("");
2741
  fputs_filtered (name, gdb_stdout);
2742
}
2743
 
2744
static void
2745
sources_info (char *ignore, int from_tty)
2746
{
2747
  struct symtab *s;
2748
  struct partial_symtab *ps;
2749
  struct objfile *objfile;
2750
  int first;
2751
 
2752
  if (!have_full_symbols () && !have_partial_symbols ())
2753
    {
2754
      error (_("No symbol table is loaded.  Use the \"file\" command."));
2755
    }
2756
 
2757
  printf_filtered ("Source files for which symbols have been read in:\n\n");
2758
 
2759
  first = 1;
2760
  ALL_SYMTABS (objfile, s)
2761
  {
2762
    const char *fullname = symtab_to_fullname (s);
2763
    output_source_filename (fullname ? fullname : s->filename, &first);
2764
  }
2765
  printf_filtered ("\n\n");
2766
 
2767
  printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
2768
 
2769
  first = 1;
2770
  ALL_PSYMTABS (objfile, ps)
2771
  {
2772
    if (!ps->readin)
2773
      {
2774
        const char *fullname = psymtab_to_fullname (ps);
2775
        output_source_filename (fullname ? fullname : ps->filename, &first);
2776
      }
2777
  }
2778
  printf_filtered ("\n");
2779
}
2780
 
2781
static int
2782
file_matches (char *file, char *files[], int nfiles)
2783
{
2784
  int i;
2785
 
2786
  if (file != NULL && nfiles != 0)
2787
    {
2788
      for (i = 0; i < nfiles; i++)
2789
        {
2790
          if (strcmp (files[i], lbasename (file)) == 0)
2791
            return 1;
2792
        }
2793
    }
2794
  else if (nfiles == 0)
2795
    return 1;
2796
  return 0;
2797
}
2798
 
2799
/* Free any memory associated with a search. */
2800
void
2801
free_search_symbols (struct symbol_search *symbols)
2802
{
2803
  struct symbol_search *p;
2804
  struct symbol_search *next;
2805
 
2806
  for (p = symbols; p != NULL; p = next)
2807
    {
2808
      next = p->next;
2809
      xfree (p);
2810
    }
2811
}
2812
 
2813
static void
2814
do_free_search_symbols_cleanup (void *symbols)
2815
{
2816
  free_search_symbols (symbols);
2817
}
2818
 
2819
struct cleanup *
2820
make_cleanup_free_search_symbols (struct symbol_search *symbols)
2821
{
2822
  return make_cleanup (do_free_search_symbols_cleanup, symbols);
2823
}
2824
 
2825
/* Helper function for sort_search_symbols and qsort.  Can only
2826
   sort symbols, not minimal symbols.  */
2827
static int
2828
compare_search_syms (const void *sa, const void *sb)
2829
{
2830
  struct symbol_search **sym_a = (struct symbol_search **) sa;
2831
  struct symbol_search **sym_b = (struct symbol_search **) sb;
2832
 
2833
  return strcmp (SYMBOL_PRINT_NAME ((*sym_a)->symbol),
2834
                 SYMBOL_PRINT_NAME ((*sym_b)->symbol));
2835
}
2836
 
2837
/* Sort the ``nfound'' symbols in the list after prevtail.  Leave
2838
   prevtail where it is, but update its next pointer to point to
2839
   the first of the sorted symbols.  */
2840
static struct symbol_search *
2841
sort_search_symbols (struct symbol_search *prevtail, int nfound)
2842
{
2843
  struct symbol_search **symbols, *symp, *old_next;
2844
  int i;
2845
 
2846
  symbols = (struct symbol_search **) xmalloc (sizeof (struct symbol_search *)
2847
                                               * nfound);
2848
  symp = prevtail->next;
2849
  for (i = 0; i < nfound; i++)
2850
    {
2851
      symbols[i] = symp;
2852
      symp = symp->next;
2853
    }
2854
  /* Generally NULL.  */
2855
  old_next = symp;
2856
 
2857
  qsort (symbols, nfound, sizeof (struct symbol_search *),
2858
         compare_search_syms);
2859
 
2860
  symp = prevtail;
2861
  for (i = 0; i < nfound; i++)
2862
    {
2863
      symp->next = symbols[i];
2864
      symp = symp->next;
2865
    }
2866
  symp->next = old_next;
2867
 
2868
  xfree (symbols);
2869
  return symp;
2870
}
2871
 
2872
/* Search the symbol table for matches to the regular expression REGEXP,
2873
   returning the results in *MATCHES.
2874
 
2875
   Only symbols of KIND are searched:
2876
   FUNCTIONS_DOMAIN - search all functions
2877
   TYPES_DOMAIN     - search all type names
2878
   METHODS_DOMAIN   - search all methods NOT IMPLEMENTED
2879
   VARIABLES_DOMAIN - search all symbols, excluding functions, type names,
2880
   and constants (enums)
2881
 
2882
   free_search_symbols should be called when *MATCHES is no longer needed.
2883
 
2884
   The results are sorted locally; each symtab's global and static blocks are
2885
   separately alphabetized.
2886
 */
2887
void
2888
search_symbols (char *regexp, domain_enum kind, int nfiles, char *files[],
2889
                struct symbol_search **matches)
2890
{
2891
  struct symtab *s;
2892
  struct partial_symtab *ps;
2893
  struct blockvector *bv;
2894
  struct block *b;
2895
  int i = 0;
2896
  struct dict_iterator iter;
2897
  struct symbol *sym;
2898
  struct partial_symbol **psym;
2899
  struct objfile *objfile;
2900
  struct minimal_symbol *msymbol;
2901
  char *val;
2902
  int found_misc = 0;
2903
  static enum minimal_symbol_type types[]
2904
  =
2905
  {mst_data, mst_text, mst_abs, mst_unknown};
2906
  static enum minimal_symbol_type types2[]
2907
  =
2908
  {mst_bss, mst_file_text, mst_abs, mst_unknown};
2909
  static enum minimal_symbol_type types3[]
2910
  =
2911
  {mst_file_data, mst_solib_trampoline, mst_abs, mst_unknown};
2912
  static enum minimal_symbol_type types4[]
2913
  =
2914
  {mst_file_bss, mst_text, mst_abs, mst_unknown};
2915
  enum minimal_symbol_type ourtype;
2916
  enum minimal_symbol_type ourtype2;
2917
  enum minimal_symbol_type ourtype3;
2918
  enum minimal_symbol_type ourtype4;
2919
  struct symbol_search *sr;
2920
  struct symbol_search *psr;
2921
  struct symbol_search *tail;
2922
  struct cleanup *old_chain = NULL;
2923
 
2924
  if (kind < VARIABLES_DOMAIN)
2925
    error (_("must search on specific domain"));
2926
 
2927
  ourtype = types[(int) (kind - VARIABLES_DOMAIN)];
2928
  ourtype2 = types2[(int) (kind - VARIABLES_DOMAIN)];
2929
  ourtype3 = types3[(int) (kind - VARIABLES_DOMAIN)];
2930
  ourtype4 = types4[(int) (kind - VARIABLES_DOMAIN)];
2931
 
2932
  sr = *matches = NULL;
2933
  tail = NULL;
2934
 
2935
  if (regexp != NULL)
2936
    {
2937
      /* Make sure spacing is right for C++ operators.
2938
         This is just a courtesy to make the matching less sensitive
2939
         to how many spaces the user leaves between 'operator'
2940
         and <TYPENAME> or <OPERATOR>. */
2941
      char *opend;
2942
      char *opname = operator_chars (regexp, &opend);
2943
      if (*opname)
2944
        {
2945
          int fix = -1;         /* -1 means ok; otherwise number of spaces needed. */
2946
          if (isalpha (*opname) || *opname == '_' || *opname == '$')
2947
            {
2948
              /* There should 1 space between 'operator' and 'TYPENAME'. */
2949
              if (opname[-1] != ' ' || opname[-2] == ' ')
2950
                fix = 1;
2951
            }
2952
          else
2953
            {
2954
              /* There should 0 spaces between 'operator' and 'OPERATOR'. */
2955
              if (opname[-1] == ' ')
2956
                fix = 0;
2957
            }
2958
          /* If wrong number of spaces, fix it. */
2959
          if (fix >= 0)
2960
            {
2961
              char *tmp = (char *) alloca (8 + fix + strlen (opname) + 1);
2962
              sprintf (tmp, "operator%.*s%s", fix, " ", opname);
2963
              regexp = tmp;
2964
            }
2965
        }
2966
 
2967
      if (0 != (val = re_comp (regexp)))
2968
        error (_("Invalid regexp (%s): %s"), val, regexp);
2969
    }
2970
 
2971
  /* Search through the partial symtabs *first* for all symbols
2972
     matching the regexp.  That way we don't have to reproduce all of
2973
     the machinery below. */
2974
 
2975
  ALL_PSYMTABS (objfile, ps)
2976
  {
2977
    struct partial_symbol **bound, **gbound, **sbound;
2978
    int keep_going = 1;
2979
 
2980
    if (ps->readin)
2981
      continue;
2982
 
2983
    gbound = objfile->global_psymbols.list + ps->globals_offset + ps->n_global_syms;
2984
    sbound = objfile->static_psymbols.list + ps->statics_offset + ps->n_static_syms;
2985
    bound = gbound;
2986
 
2987
    /* Go through all of the symbols stored in a partial
2988
       symtab in one loop. */
2989
    psym = objfile->global_psymbols.list + ps->globals_offset;
2990
    while (keep_going)
2991
      {
2992
        if (psym >= bound)
2993
          {
2994
            if (bound == gbound && ps->n_static_syms != 0)
2995
              {
2996
                psym = objfile->static_psymbols.list + ps->statics_offset;
2997
                bound = sbound;
2998
              }
2999
            else
3000
              keep_going = 0;
3001
            continue;
3002
          }
3003
        else
3004
          {
3005
            QUIT;
3006
 
3007
            /* If it would match (logic taken from loop below)
3008
               load the file and go on to the next one.  We check the
3009
               filename here, but that's a bit bogus: we don't know
3010
               what file it really comes from until we have full
3011
               symtabs.  The symbol might be in a header file included by
3012
               this psymtab.  This only affects Insight.  */
3013
            if (file_matches (ps->filename, files, nfiles)
3014
                && ((regexp == NULL
3015
                     || re_exec (SYMBOL_NATURAL_NAME (*psym)) != 0)
3016
                    && ((kind == VARIABLES_DOMAIN && SYMBOL_CLASS (*psym) != LOC_TYPEDEF
3017
                         && SYMBOL_CLASS (*psym) != LOC_BLOCK)
3018
                        || (kind == FUNCTIONS_DOMAIN && SYMBOL_CLASS (*psym) == LOC_BLOCK)
3019
                        || (kind == TYPES_DOMAIN && SYMBOL_CLASS (*psym) == LOC_TYPEDEF)
3020
                        || (kind == METHODS_DOMAIN && SYMBOL_CLASS (*psym) == LOC_BLOCK))))
3021
              {
3022
                PSYMTAB_TO_SYMTAB (ps);
3023
                keep_going = 0;
3024
              }
3025
          }
3026
        psym++;
3027
      }
3028
  }
3029
 
3030
  /* Here, we search through the minimal symbol tables for functions
3031
     and variables that match, and force their symbols to be read.
3032
     This is in particular necessary for demangled variable names,
3033
     which are no longer put into the partial symbol tables.
3034
     The symbol will then be found during the scan of symtabs below.
3035
 
3036
     For functions, find_pc_symtab should succeed if we have debug info
3037
     for the function, for variables we have to call lookup_symbol
3038
     to determine if the variable has debug info.
3039
     If the lookup fails, set found_misc so that we will rescan to print
3040
     any matching symbols without debug info.
3041
   */
3042
 
3043
  if (nfiles == 0 && (kind == VARIABLES_DOMAIN || kind == FUNCTIONS_DOMAIN))
3044
    {
3045
      ALL_MSYMBOLS (objfile, msymbol)
3046
      {
3047
        if (MSYMBOL_TYPE (msymbol) == ourtype ||
3048
            MSYMBOL_TYPE (msymbol) == ourtype2 ||
3049
            MSYMBOL_TYPE (msymbol) == ourtype3 ||
3050
            MSYMBOL_TYPE (msymbol) == ourtype4)
3051
          {
3052
            if (regexp == NULL
3053
                || re_exec (SYMBOL_NATURAL_NAME (msymbol)) != 0)
3054
              {
3055
                if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol)))
3056
                  {
3057
                    /* FIXME: carlton/2003-02-04: Given that the
3058
                       semantics of lookup_symbol keeps on changing
3059
                       slightly, it would be a nice idea if we had a
3060
                       function lookup_symbol_minsym that found the
3061
                       symbol associated to a given minimal symbol (if
3062
                       any).  */
3063
                    if (kind == FUNCTIONS_DOMAIN
3064
                        || lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol),
3065
                                          (struct block *) NULL,
3066
                                          VAR_DOMAIN,
3067
                                          0, (struct symtab **) NULL)
3068
                        == NULL)
3069
                      found_misc = 1;
3070
                  }
3071
              }
3072
          }
3073
      }
3074
    }
3075
 
3076
  ALL_PRIMARY_SYMTABS (objfile, s)
3077
  {
3078
    bv = BLOCKVECTOR (s);
3079
      for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++)
3080
        {
3081
          struct symbol_search *prevtail = tail;
3082
          int nfound = 0;
3083
          b = BLOCKVECTOR_BLOCK (bv, i);
3084
          ALL_BLOCK_SYMBOLS (b, iter, sym)
3085
            {
3086
              struct symtab *real_symtab = SYMBOL_SYMTAB (sym);
3087
              QUIT;
3088
 
3089
              if (file_matches (real_symtab->filename, files, nfiles)
3090
                  && ((regexp == NULL
3091
                       || re_exec (SYMBOL_NATURAL_NAME (sym)) != 0)
3092
                      && ((kind == VARIABLES_DOMAIN && SYMBOL_CLASS (sym) != LOC_TYPEDEF
3093
                           && SYMBOL_CLASS (sym) != LOC_BLOCK
3094
                           && SYMBOL_CLASS (sym) != LOC_CONST)
3095
                          || (kind == FUNCTIONS_DOMAIN && SYMBOL_CLASS (sym) == LOC_BLOCK)
3096
                          || (kind == TYPES_DOMAIN && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
3097
                          || (kind == METHODS_DOMAIN && SYMBOL_CLASS (sym) == LOC_BLOCK))))
3098
                {
3099
                  /* match */
3100
                  psr = (struct symbol_search *) xmalloc (sizeof (struct symbol_search));
3101
                  psr->block = i;
3102
                  psr->symtab = real_symtab;
3103
                  psr->symbol = sym;
3104
                  psr->msymbol = NULL;
3105
                  psr->next = NULL;
3106
                  if (tail == NULL)
3107
                    sr = psr;
3108
                  else
3109
                    tail->next = psr;
3110
                  tail = psr;
3111
                  nfound ++;
3112
                }
3113
            }
3114
          if (nfound > 0)
3115
            {
3116
              if (prevtail == NULL)
3117
                {
3118
                  struct symbol_search dummy;
3119
 
3120
                  dummy.next = sr;
3121
                  tail = sort_search_symbols (&dummy, nfound);
3122
                  sr = dummy.next;
3123
 
3124
                  old_chain = make_cleanup_free_search_symbols (sr);
3125
                }
3126
              else
3127
                tail = sort_search_symbols (prevtail, nfound);
3128
            }
3129
        }
3130
  }
3131
 
3132
  /* If there are no eyes, avoid all contact.  I mean, if there are
3133
     no debug symbols, then print directly from the msymbol_vector.  */
3134
 
3135
  if (found_misc || kind != FUNCTIONS_DOMAIN)
3136
    {
3137
      ALL_MSYMBOLS (objfile, msymbol)
3138
      {
3139
        if (MSYMBOL_TYPE (msymbol) == ourtype ||
3140
            MSYMBOL_TYPE (msymbol) == ourtype2 ||
3141
            MSYMBOL_TYPE (msymbol) == ourtype3 ||
3142
            MSYMBOL_TYPE (msymbol) == ourtype4)
3143
          {
3144
            if (regexp == NULL
3145
                || re_exec (SYMBOL_NATURAL_NAME (msymbol)) != 0)
3146
              {
3147
                /* Functions:  Look up by address. */
3148
                if (kind != FUNCTIONS_DOMAIN ||
3149
                    (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol))))
3150
                  {
3151
                    /* Variables/Absolutes:  Look up by name */
3152
                    if (lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol),
3153
                                       (struct block *) NULL, VAR_DOMAIN,
3154
                                       0, (struct symtab **) NULL) == NULL)
3155
                      {
3156
                        /* match */
3157
                        psr = (struct symbol_search *) xmalloc (sizeof (struct symbol_search));
3158
                        psr->block = i;
3159
                        psr->msymbol = msymbol;
3160
                        psr->symtab = NULL;
3161
                        psr->symbol = NULL;
3162
                        psr->next = NULL;
3163
                        if (tail == NULL)
3164
                          {
3165
                            sr = psr;
3166
                            old_chain = make_cleanup_free_search_symbols (sr);
3167
                          }
3168
                        else
3169
                          tail->next = psr;
3170
                        tail = psr;
3171
                      }
3172
                  }
3173
              }
3174
          }
3175
      }
3176
    }
3177
 
3178
  *matches = sr;
3179
  if (sr != NULL)
3180
    discard_cleanups (old_chain);
3181
}
3182
 
3183
/* Helper function for symtab_symbol_info, this function uses
3184
   the data returned from search_symbols() to print information
3185
   regarding the match to gdb_stdout.
3186
 */
3187
static void
3188
print_symbol_info (domain_enum kind, struct symtab *s, struct symbol *sym,
3189
                   int block, char *last)
3190
{
3191
  if (last == NULL || strcmp (last, s->filename) != 0)
3192
    {
3193
      fputs_filtered ("\nFile ", gdb_stdout);
3194
      fputs_filtered (s->filename, gdb_stdout);
3195
      fputs_filtered (":\n", gdb_stdout);
3196
    }
3197
 
3198
  if (kind != TYPES_DOMAIN && block == STATIC_BLOCK)
3199
    printf_filtered ("static ");
3200
 
3201
  /* Typedef that is not a C++ class */
3202
  if (kind == TYPES_DOMAIN
3203
      && SYMBOL_DOMAIN (sym) != STRUCT_DOMAIN)
3204
    typedef_print (SYMBOL_TYPE (sym), sym, gdb_stdout);
3205
  /* variable, func, or typedef-that-is-c++-class */
3206
  else if (kind < TYPES_DOMAIN ||
3207
           (kind == TYPES_DOMAIN &&
3208
            SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN))
3209
    {
3210
      type_print (SYMBOL_TYPE (sym),
3211
                  (SYMBOL_CLASS (sym) == LOC_TYPEDEF
3212
                   ? "" : SYMBOL_PRINT_NAME (sym)),
3213
                  gdb_stdout, 0);
3214
 
3215
      printf_filtered (";\n");
3216
    }
3217
}
3218
 
3219
/* This help function for symtab_symbol_info() prints information
3220
   for non-debugging symbols to gdb_stdout.
3221
 */
3222
static void
3223
print_msymbol_info (struct minimal_symbol *msymbol)
3224
{
3225
  char *tmp;
3226
 
3227
  if (gdbarch_addr_bit (current_gdbarch) <= 32)
3228
    tmp = hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol)
3229
                             & (CORE_ADDR) 0xffffffff,
3230
                             8);
3231
  else
3232
    tmp = hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol),
3233
                             16);
3234
  printf_filtered ("%s  %s\n",
3235
                   tmp, SYMBOL_PRINT_NAME (msymbol));
3236
}
3237
 
3238
/* This is the guts of the commands "info functions", "info types", and
3239
   "info variables". It calls search_symbols to find all matches and then
3240
   print_[m]symbol_info to print out some useful information about the
3241
   matches.
3242
 */
3243
static void
3244
symtab_symbol_info (char *regexp, domain_enum kind, int from_tty)
3245
{
3246
  static char *classnames[]
3247
  =
3248
  {"variable", "function", "type", "method"};
3249
  struct symbol_search *symbols;
3250
  struct symbol_search *p;
3251
  struct cleanup *old_chain;
3252
  char *last_filename = NULL;
3253
  int first = 1;
3254
 
3255
  /* must make sure that if we're interrupted, symbols gets freed */
3256
  search_symbols (regexp, kind, 0, (char **) NULL, &symbols);
3257
  old_chain = make_cleanup_free_search_symbols (symbols);
3258
 
3259
  printf_filtered (regexp
3260
                   ? "All %ss matching regular expression \"%s\":\n"
3261
                   : "All defined %ss:\n",
3262
                   classnames[(int) (kind - VARIABLES_DOMAIN)], regexp);
3263
 
3264
  for (p = symbols; p != NULL; p = p->next)
3265
    {
3266
      QUIT;
3267
 
3268
      if (p->msymbol != NULL)
3269
        {
3270
          if (first)
3271
            {
3272
              printf_filtered ("\nNon-debugging symbols:\n");
3273
              first = 0;
3274
            }
3275
          print_msymbol_info (p->msymbol);
3276
        }
3277
      else
3278
        {
3279
          print_symbol_info (kind,
3280
                             p->symtab,
3281
                             p->symbol,
3282
                             p->block,
3283
                             last_filename);
3284
          last_filename = p->symtab->filename;
3285
        }
3286
    }
3287
 
3288
  do_cleanups (old_chain);
3289
}
3290
 
3291
static void
3292
variables_info (char *regexp, int from_tty)
3293
{
3294
  symtab_symbol_info (regexp, VARIABLES_DOMAIN, from_tty);
3295
}
3296
 
3297
static void
3298
functions_info (char *regexp, int from_tty)
3299
{
3300
  symtab_symbol_info (regexp, FUNCTIONS_DOMAIN, from_tty);
3301
}
3302
 
3303
 
3304
static void
3305
types_info (char *regexp, int from_tty)
3306
{
3307
  symtab_symbol_info (regexp, TYPES_DOMAIN, from_tty);
3308
}
3309
 
3310
/* Breakpoint all functions matching regular expression. */
3311
 
3312
void
3313
rbreak_command_wrapper (char *regexp, int from_tty)
3314
{
3315
  rbreak_command (regexp, from_tty);
3316
}
3317
 
3318
static void
3319
rbreak_command (char *regexp, int from_tty)
3320
{
3321
  struct symbol_search *ss;
3322
  struct symbol_search *p;
3323
  struct cleanup *old_chain;
3324
 
3325
  search_symbols (regexp, FUNCTIONS_DOMAIN, 0, (char **) NULL, &ss);
3326
  old_chain = make_cleanup_free_search_symbols (ss);
3327
 
3328
  for (p = ss; p != NULL; p = p->next)
3329
    {
3330
      if (p->msymbol == NULL)
3331
        {
3332
          char *string = alloca (strlen (p->symtab->filename)
3333
                                 + strlen (SYMBOL_LINKAGE_NAME (p->symbol))
3334
                                 + 4);
3335
          strcpy (string, p->symtab->filename);
3336
          strcat (string, ":'");
3337
          strcat (string, SYMBOL_LINKAGE_NAME (p->symbol));
3338
          strcat (string, "'");
3339
          break_command (string, from_tty);
3340
          print_symbol_info (FUNCTIONS_DOMAIN,
3341
                             p->symtab,
3342
                             p->symbol,
3343
                             p->block,
3344
                             p->symtab->filename);
3345
        }
3346
      else
3347
        {
3348
          break_command (SYMBOL_LINKAGE_NAME (p->msymbol), from_tty);
3349
          printf_filtered ("<function, no debug info> %s;\n",
3350
                           SYMBOL_PRINT_NAME (p->msymbol));
3351
        }
3352
    }
3353
 
3354
  do_cleanups (old_chain);
3355
}
3356
 
3357
 
3358
/* Helper routine for make_symbol_completion_list.  */
3359
 
3360
static int return_val_size;
3361
static int return_val_index;
3362
static char **return_val;
3363
 
3364
#define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
3365
      completion_list_add_name \
3366
        (SYMBOL_NATURAL_NAME (symbol), (sym_text), (len), (text), (word))
3367
 
3368
/*  Test to see if the symbol specified by SYMNAME (which is already
3369
   demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
3370
   characters.  If so, add it to the current completion list. */
3371
 
3372
static void
3373
completion_list_add_name (char *symname, char *sym_text, int sym_text_len,
3374
                          char *text, char *word)
3375
{
3376
  int newsize;
3377
  int i;
3378
 
3379
  /* clip symbols that cannot match */
3380
 
3381
  if (strncmp (symname, sym_text, sym_text_len) != 0)
3382
    {
3383
      return;
3384
    }
3385
 
3386
  /* We have a match for a completion, so add SYMNAME to the current list
3387
     of matches. Note that the name is moved to freshly malloc'd space. */
3388
 
3389
  {
3390
    char *new;
3391
    if (word == sym_text)
3392
      {
3393
        new = xmalloc (strlen (symname) + 5);
3394
        strcpy (new, symname);
3395
      }
3396
    else if (word > sym_text)
3397
      {
3398
        /* Return some portion of symname.  */
3399
        new = xmalloc (strlen (symname) + 5);
3400
        strcpy (new, symname + (word - sym_text));
3401
      }
3402
    else
3403
      {
3404
        /* Return some of SYM_TEXT plus symname.  */
3405
        new = xmalloc (strlen (symname) + (sym_text - word) + 5);
3406
        strncpy (new, word, sym_text - word);
3407
        new[sym_text - word] = '\0';
3408
        strcat (new, symname);
3409
      }
3410
 
3411
    if (return_val_index + 3 > return_val_size)
3412
      {
3413
        newsize = (return_val_size *= 2) * sizeof (char *);
3414
        return_val = (char **) xrealloc ((char *) return_val, newsize);
3415
      }
3416
    return_val[return_val_index++] = new;
3417
    return_val[return_val_index] = NULL;
3418
  }
3419
}
3420
 
3421
/* ObjC: In case we are completing on a selector, look as the msymbol
3422
   again and feed all the selectors into the mill.  */
3423
 
3424
static void
3425
completion_list_objc_symbol (struct minimal_symbol *msymbol, char *sym_text,
3426
                             int sym_text_len, char *text, char *word)
3427
{
3428
  static char *tmp = NULL;
3429
  static unsigned int tmplen = 0;
3430
 
3431
  char *method, *category, *selector;
3432
  char *tmp2 = NULL;
3433
 
3434
  method = SYMBOL_NATURAL_NAME (msymbol);
3435
 
3436
  /* Is it a method?  */
3437
  if ((method[0] != '-') && (method[0] != '+'))
3438
    return;
3439
 
3440
  if (sym_text[0] == '[')
3441
    /* Complete on shortened method method.  */
3442
    completion_list_add_name (method + 1, sym_text, sym_text_len, text, word);
3443
 
3444
  while ((strlen (method) + 1) >= tmplen)
3445
    {
3446
      if (tmplen == 0)
3447
        tmplen = 1024;
3448
      else
3449
        tmplen *= 2;
3450
      tmp = xrealloc (tmp, tmplen);
3451
    }
3452
  selector = strchr (method, ' ');
3453
  if (selector != NULL)
3454
    selector++;
3455
 
3456
  category = strchr (method, '(');
3457
 
3458
  if ((category != NULL) && (selector != NULL))
3459
    {
3460
      memcpy (tmp, method, (category - method));
3461
      tmp[category - method] = ' ';
3462
      memcpy (tmp + (category - method) + 1, selector, strlen (selector) + 1);
3463
      completion_list_add_name (tmp, sym_text, sym_text_len, text, word);
3464
      if (sym_text[0] == '[')
3465
        completion_list_add_name (tmp + 1, sym_text, sym_text_len, text, word);
3466
    }
3467
 
3468
  if (selector != NULL)
3469
    {
3470
      /* Complete on selector only.  */
3471
      strcpy (tmp, selector);
3472
      tmp2 = strchr (tmp, ']');
3473
      if (tmp2 != NULL)
3474
        *tmp2 = '\0';
3475
 
3476
      completion_list_add_name (tmp, sym_text, sym_text_len, text, word);
3477
    }
3478
}
3479
 
3480
/* Break the non-quoted text based on the characters which are in
3481
   symbols. FIXME: This should probably be language-specific. */
3482
 
3483
static char *
3484
language_search_unquoted_string (char *text, char *p)
3485
{
3486
  for (; p > text; --p)
3487
    {
3488
      if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0')
3489
        continue;
3490
      else
3491
        {
3492
          if ((current_language->la_language == language_objc))
3493
            {
3494
              if (p[-1] == ':')     /* might be part of a method name */
3495
                continue;
3496
              else if (p[-1] == '[' && (p[-2] == '-' || p[-2] == '+'))
3497
                p -= 2;             /* beginning of a method name */
3498
              else if (p[-1] == ' ' || p[-1] == '(' || p[-1] == ')')
3499
                {                   /* might be part of a method name */
3500
                  char *t = p;
3501
 
3502
                  /* Seeing a ' ' or a '(' is not conclusive evidence
3503
                     that we are in the middle of a method name.  However,
3504
                     finding "-[" or "+[" should be pretty un-ambiguous.
3505
                     Unfortunately we have to find it now to decide.  */
3506
 
3507
                  while (t > text)
3508
                    if (isalnum (t[-1]) || t[-1] == '_' ||
3509
                        t[-1] == ' '    || t[-1] == ':' ||
3510
                        t[-1] == '('    || t[-1] == ')')
3511
                      --t;
3512
                    else
3513
                      break;
3514
 
3515
                  if (t[-1] == '[' && (t[-2] == '-' || t[-2] == '+'))
3516
                    p = t - 2;      /* method name detected */
3517
                  /* else we leave with p unchanged */
3518
                }
3519
            }
3520
          break;
3521
        }
3522
    }
3523
  return p;
3524
}
3525
 
3526
char **
3527
default_make_symbol_completion_list (char *text, char *word)
3528
{
3529
  /* Problem: All of the symbols have to be copied because readline
3530
     frees them.  I'm not going to worry about this; hopefully there
3531
     won't be that many.  */
3532
 
3533
  struct symbol *sym;
3534
  struct symtab *s;
3535
  struct partial_symtab *ps;
3536
  struct minimal_symbol *msymbol;
3537
  struct objfile *objfile;
3538
  struct block *b, *surrounding_static_block = 0;
3539
  struct dict_iterator iter;
3540
  int j;
3541
  struct partial_symbol **psym;
3542
  /* The symbol we are completing on.  Points in same buffer as text.  */
3543
  char *sym_text;
3544
  /* Length of sym_text.  */
3545
  int sym_text_len;
3546
 
3547
  /* Now look for the symbol we are supposed to complete on.  */
3548
  {
3549
    char *p;
3550
    char quote_found;
3551
    char *quote_pos = NULL;
3552
 
3553
    /* First see if this is a quoted string.  */
3554
    quote_found = '\0';
3555
    for (p = text; *p != '\0'; ++p)
3556
      {
3557
        if (quote_found != '\0')
3558
          {
3559
            if (*p == quote_found)
3560
              /* Found close quote.  */
3561
              quote_found = '\0';
3562
            else if (*p == '\\' && p[1] == quote_found)
3563
              /* A backslash followed by the quote character
3564
                 doesn't end the string.  */
3565
              ++p;
3566
          }
3567
        else if (*p == '\'' || *p == '"')
3568
          {
3569
            quote_found = *p;
3570
            quote_pos = p;
3571
          }
3572
      }
3573
    if (quote_found == '\'')
3574
      /* A string within single quotes can be a symbol, so complete on it.  */
3575
      sym_text = quote_pos + 1;
3576
    else if (quote_found == '"')
3577
      /* A double-quoted string is never a symbol, nor does it make sense
3578
         to complete it any other way.  */
3579
      {
3580
        return_val = (char **) xmalloc (sizeof (char *));
3581
        return_val[0] = NULL;
3582
        return return_val;
3583
      }
3584
    else
3585
      {
3586
        /* It is not a quoted string.  Break it based on the characters
3587
           which are in symbols.  */
3588
        while (p > text)
3589
          {
3590
            if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0')
3591
              --p;
3592
            else
3593
              break;
3594
          }
3595
        sym_text = p;
3596
      }
3597
  }
3598
 
3599
  sym_text_len = strlen (sym_text);
3600
 
3601
  return_val_size = 100;
3602
  return_val_index = 0;
3603
  return_val = (char **) xmalloc ((return_val_size + 1) * sizeof (char *));
3604
  return_val[0] = NULL;
3605
 
3606
  /* Look through the partial symtabs for all symbols which begin
3607
     by matching SYM_TEXT.  Add each one that you find to the list.  */
3608
 
3609
  ALL_PSYMTABS (objfile, ps)
3610
  {
3611
    /* If the psymtab's been read in we'll get it when we search
3612
       through the blockvector.  */
3613
    if (ps->readin)
3614
      continue;
3615
 
3616
    for (psym = objfile->global_psymbols.list + ps->globals_offset;
3617
         psym < (objfile->global_psymbols.list + ps->globals_offset
3618
                 + ps->n_global_syms);
3619
         psym++)
3620
      {
3621
        /* If interrupted, then quit. */
3622
        QUIT;
3623
        COMPLETION_LIST_ADD_SYMBOL (*psym, sym_text, sym_text_len, text, word);
3624
      }
3625
 
3626
    for (psym = objfile->static_psymbols.list + ps->statics_offset;
3627
         psym < (objfile->static_psymbols.list + ps->statics_offset
3628
                 + ps->n_static_syms);
3629
         psym++)
3630
      {
3631
        QUIT;
3632
        COMPLETION_LIST_ADD_SYMBOL (*psym, sym_text, sym_text_len, text, word);
3633
      }
3634
  }
3635
 
3636
  /* At this point scan through the misc symbol vectors and add each
3637
     symbol you find to the list.  Eventually we want to ignore
3638
     anything that isn't a text symbol (everything else will be
3639
     handled by the psymtab code above).  */
3640
 
3641
  ALL_MSYMBOLS (objfile, msymbol)
3642
  {
3643
    QUIT;
3644
    COMPLETION_LIST_ADD_SYMBOL (msymbol, sym_text, sym_text_len, text, word);
3645
 
3646
    completion_list_objc_symbol (msymbol, sym_text, sym_text_len, text, word);
3647
  }
3648
 
3649
  /* Search upwards from currently selected frame (so that we can
3650
     complete on local vars.  */
3651
 
3652
  for (b = get_selected_block (0); b != NULL; b = BLOCK_SUPERBLOCK (b))
3653
    {
3654
      if (!BLOCK_SUPERBLOCK (b))
3655
        {
3656
          surrounding_static_block = b;         /* For elmin of dups */
3657
        }
3658
 
3659
      /* Also catch fields of types defined in this places which match our
3660
         text string.  Only complete on types visible from current context. */
3661
 
3662
      ALL_BLOCK_SYMBOLS (b, iter, sym)
3663
        {
3664
          QUIT;
3665
          COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
3666
          if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
3667
            {
3668
              struct type *t = SYMBOL_TYPE (sym);
3669
              enum type_code c = TYPE_CODE (t);
3670
 
3671
              if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT)
3672
                {
3673
                  for (j = TYPE_N_BASECLASSES (t); j < TYPE_NFIELDS (t); j++)
3674
                    {
3675
                      if (TYPE_FIELD_NAME (t, j))
3676
                        {
3677
                          completion_list_add_name (TYPE_FIELD_NAME (t, j),
3678
                                        sym_text, sym_text_len, text, word);
3679
                        }
3680
                    }
3681
                }
3682
            }
3683
        }
3684
    }
3685
 
3686
  /* Go through the symtabs and check the externs and statics for
3687
     symbols which match.  */
3688
 
3689
  ALL_PRIMARY_SYMTABS (objfile, s)
3690
  {
3691
    QUIT;
3692
    b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
3693
    ALL_BLOCK_SYMBOLS (b, iter, sym)
3694
      {
3695
        COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
3696
      }
3697
  }
3698
 
3699
  ALL_PRIMARY_SYMTABS (objfile, s)
3700
  {
3701
    QUIT;
3702
    b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
3703
    /* Don't do this block twice.  */
3704
    if (b == surrounding_static_block)
3705
      continue;
3706
    ALL_BLOCK_SYMBOLS (b, iter, sym)
3707
      {
3708
        COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
3709
      }
3710
  }
3711
 
3712
  return (return_val);
3713
}
3714
 
3715
/* Return a NULL terminated array of all symbols (regardless of class)
3716
   which begin by matching TEXT.  If the answer is no symbols, then
3717
   the return value is an array which contains only a NULL pointer.  */
3718
 
3719
char **
3720
make_symbol_completion_list (char *text, char *word)
3721
{
3722
  return current_language->la_make_symbol_completion_list (text, word);
3723
}
3724
 
3725
/* Like make_symbol_completion_list, but returns a list of symbols
3726
   defined in a source file FILE.  */
3727
 
3728
char **
3729
make_file_symbol_completion_list (char *text, char *word, char *srcfile)
3730
{
3731
  struct symbol *sym;
3732
  struct symtab *s;
3733
  struct block *b;
3734
  struct dict_iterator iter;
3735
  /* The symbol we are completing on.  Points in same buffer as text.  */
3736
  char *sym_text;
3737
  /* Length of sym_text.  */
3738
  int sym_text_len;
3739
 
3740
  /* Now look for the symbol we are supposed to complete on.
3741
     FIXME: This should be language-specific.  */
3742
  {
3743
    char *p;
3744
    char quote_found;
3745
    char *quote_pos = NULL;
3746
 
3747
    /* First see if this is a quoted string.  */
3748
    quote_found = '\0';
3749
    for (p = text; *p != '\0'; ++p)
3750
      {
3751
        if (quote_found != '\0')
3752
          {
3753
            if (*p == quote_found)
3754
              /* Found close quote.  */
3755
              quote_found = '\0';
3756
            else if (*p == '\\' && p[1] == quote_found)
3757
              /* A backslash followed by the quote character
3758
                 doesn't end the string.  */
3759
              ++p;
3760
          }
3761
        else if (*p == '\'' || *p == '"')
3762
          {
3763
            quote_found = *p;
3764
            quote_pos = p;
3765
          }
3766
      }
3767
    if (quote_found == '\'')
3768
      /* A string within single quotes can be a symbol, so complete on it.  */
3769
      sym_text = quote_pos + 1;
3770
    else if (quote_found == '"')
3771
      /* A double-quoted string is never a symbol, nor does it make sense
3772
         to complete it any other way.  */
3773
      {
3774
        return_val = (char **) xmalloc (sizeof (char *));
3775
        return_val[0] = NULL;
3776
        return return_val;
3777
      }
3778
    else
3779
      {
3780
        /* Not a quoted string.  */
3781
        sym_text = language_search_unquoted_string (text, p);
3782
      }
3783
  }
3784
 
3785
  sym_text_len = strlen (sym_text);
3786
 
3787
  return_val_size = 10;
3788
  return_val_index = 0;
3789
  return_val = (char **) xmalloc ((return_val_size + 1) * sizeof (char *));
3790
  return_val[0] = NULL;
3791
 
3792
  /* Find the symtab for SRCFILE (this loads it if it was not yet read
3793
     in).  */
3794
  s = lookup_symtab (srcfile);
3795
  if (s == NULL)
3796
    {
3797
      /* Maybe they typed the file with leading directories, while the
3798
         symbol tables record only its basename.  */
3799
      const char *tail = lbasename (srcfile);
3800
 
3801
      if (tail > srcfile)
3802
        s = lookup_symtab (tail);
3803
    }
3804
 
3805
  /* If we have no symtab for that file, return an empty list.  */
3806
  if (s == NULL)
3807
    return (return_val);
3808
 
3809
  /* Go through this symtab and check the externs and statics for
3810
     symbols which match.  */
3811
 
3812
  b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
3813
  ALL_BLOCK_SYMBOLS (b, iter, sym)
3814
    {
3815
      COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
3816
    }
3817
 
3818
  b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
3819
  ALL_BLOCK_SYMBOLS (b, iter, sym)
3820
    {
3821
      COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
3822
    }
3823
 
3824
  return (return_val);
3825
}
3826
 
3827
/* A helper function for make_source_files_completion_list.  It adds
3828
   another file name to a list of possible completions, growing the
3829
   list as necessary.  */
3830
 
3831
static void
3832
add_filename_to_list (const char *fname, char *text, char *word,
3833
                      char ***list, int *list_used, int *list_alloced)
3834
{
3835
  char *new;
3836
  size_t fnlen = strlen (fname);
3837
 
3838
  if (*list_used + 1 >= *list_alloced)
3839
    {
3840
      *list_alloced *= 2;
3841
      *list = (char **) xrealloc ((char *) *list,
3842
                                  *list_alloced * sizeof (char *));
3843
    }
3844
 
3845
  if (word == text)
3846
    {
3847
      /* Return exactly fname.  */
3848
      new = xmalloc (fnlen + 5);
3849
      strcpy (new, fname);
3850
    }
3851
  else if (word > text)
3852
    {
3853
      /* Return some portion of fname.  */
3854
      new = xmalloc (fnlen + 5);
3855
      strcpy (new, fname + (word - text));
3856
    }
3857
  else
3858
    {
3859
      /* Return some of TEXT plus fname.  */
3860
      new = xmalloc (fnlen + (text - word) + 5);
3861
      strncpy (new, word, text - word);
3862
      new[text - word] = '\0';
3863
      strcat (new, fname);
3864
    }
3865
  (*list)[*list_used] = new;
3866
  (*list)[++*list_used] = NULL;
3867
}
3868
 
3869
static int
3870
not_interesting_fname (const char *fname)
3871
{
3872
  static const char *illegal_aliens[] = {
3873
    "_globals_",        /* inserted by coff_symtab_read */
3874
    NULL
3875
  };
3876
  int i;
3877
 
3878
  for (i = 0; illegal_aliens[i]; i++)
3879
    {
3880
      if (strcmp (fname, illegal_aliens[i]) == 0)
3881
        return 1;
3882
    }
3883
  return 0;
3884
}
3885
 
3886
/* Return a NULL terminated array of all source files whose names
3887
   begin with matching TEXT.  The file names are looked up in the
3888
   symbol tables of this program.  If the answer is no matchess, then
3889
   the return value is an array which contains only a NULL pointer.  */
3890
 
3891
char **
3892
make_source_files_completion_list (char *text, char *word)
3893
{
3894
  struct symtab *s;
3895
  struct partial_symtab *ps;
3896
  struct objfile *objfile;
3897
  int first = 1;
3898
  int list_alloced = 1;
3899
  int list_used = 0;
3900
  size_t text_len = strlen (text);
3901
  char **list = (char **) xmalloc (list_alloced * sizeof (char *));
3902
  const char *base_name;
3903
 
3904
  list[0] = NULL;
3905
 
3906
  if (!have_full_symbols () && !have_partial_symbols ())
3907
    return list;
3908
 
3909
  ALL_SYMTABS (objfile, s)
3910
    {
3911
      if (not_interesting_fname (s->filename))
3912
        continue;
3913
      if (!filename_seen (s->filename, 1, &first)
3914
#if HAVE_DOS_BASED_FILE_SYSTEM
3915
          && strncasecmp (s->filename, text, text_len) == 0
3916
#else
3917
          && strncmp (s->filename, text, text_len) == 0
3918
#endif
3919
          )
3920
        {
3921
          /* This file matches for a completion; add it to the current
3922
             list of matches.  */
3923
          add_filename_to_list (s->filename, text, word,
3924
                                &list, &list_used, &list_alloced);
3925
        }
3926
      else
3927
        {
3928
          /* NOTE: We allow the user to type a base name when the
3929
             debug info records leading directories, but not the other
3930
             way around.  This is what subroutines of breakpoint
3931
             command do when they parse file names.  */
3932
          base_name = lbasename (s->filename);
3933
          if (base_name != s->filename
3934
              && !filename_seen (base_name, 1, &first)
3935
#if HAVE_DOS_BASED_FILE_SYSTEM
3936
              && strncasecmp (base_name, text, text_len) == 0
3937
#else
3938
              && strncmp (base_name, text, text_len) == 0
3939
#endif
3940
              )
3941
            add_filename_to_list (base_name, text, word,
3942
                                  &list, &list_used, &list_alloced);
3943
        }
3944
    }
3945
 
3946
  ALL_PSYMTABS (objfile, ps)
3947
    {
3948
      if (not_interesting_fname (ps->filename))
3949
        continue;
3950
      if (!ps->readin)
3951
        {
3952
          if (!filename_seen (ps->filename, 1, &first)
3953
#if HAVE_DOS_BASED_FILE_SYSTEM
3954
              && strncasecmp (ps->filename, text, text_len) == 0
3955
#else
3956
              && strncmp (ps->filename, text, text_len) == 0
3957
#endif
3958
              )
3959
            {
3960
              /* This file matches for a completion; add it to the
3961
                 current list of matches.  */
3962
              add_filename_to_list (ps->filename, text, word,
3963
                                    &list, &list_used, &list_alloced);
3964
 
3965
            }
3966
          else
3967
            {
3968
              base_name = lbasename (ps->filename);
3969
              if (base_name != ps->filename
3970
                  && !filename_seen (base_name, 1, &first)
3971
#if HAVE_DOS_BASED_FILE_SYSTEM
3972
                  && strncasecmp (base_name, text, text_len) == 0
3973
#else
3974
                  && strncmp (base_name, text, text_len) == 0
3975
#endif
3976
                  )
3977
                add_filename_to_list (base_name, text, word,
3978
                                      &list, &list_used, &list_alloced);
3979
            }
3980
        }
3981
    }
3982
 
3983
  return list;
3984
}
3985
 
3986
/* Determine if PC is in the prologue of a function.  The prologue is the area
3987
   between the first instruction of a function, and the first executable line.
3988
   Returns 1 if PC *might* be in prologue, 0 if definately *not* in prologue.
3989
 
3990
   If non-zero, func_start is where we think the prologue starts, possibly
3991
   by previous examination of symbol table information.
3992
 */
3993
 
3994
int
3995
in_prologue (CORE_ADDR pc, CORE_ADDR func_start)
3996
{
3997
  struct symtab_and_line sal;
3998
  CORE_ADDR func_addr, func_end;
3999
 
4000
  /* We have several sources of information we can consult to figure
4001
     this out.
4002
     - Compilers usually emit line number info that marks the prologue
4003
       as its own "source line".  So the ending address of that "line"
4004
       is the end of the prologue.  If available, this is the most
4005
       reliable method.
4006
     - The minimal symbols and partial symbols, which can usually tell
4007
       us the starting and ending addresses of a function.
4008
     - If we know the function's start address, we can call the
4009
       architecture-defined gdbarch_skip_prologue function to analyze the
4010
       instruction stream and guess where the prologue ends.
4011
     - Our `func_start' argument; if non-zero, this is the caller's
4012
       best guess as to the function's entry point.  At the time of
4013
       this writing, handle_inferior_event doesn't get this right, so
4014
       it should be our last resort.  */
4015
 
4016
  /* Consult the partial symbol table, to find which function
4017
     the PC is in.  */
4018
  if (! find_pc_partial_function (pc, NULL, &func_addr, &func_end))
4019
    {
4020
      CORE_ADDR prologue_end;
4021
 
4022
      /* We don't even have minsym information, so fall back to using
4023
         func_start, if given.  */
4024
      if (! func_start)
4025
        return 1;               /* We *might* be in a prologue.  */
4026
 
4027
      prologue_end = gdbarch_skip_prologue (current_gdbarch, func_start);
4028
 
4029
      return func_start <= pc && pc < prologue_end;
4030
    }
4031
 
4032
  /* If we have line number information for the function, that's
4033
     usually pretty reliable.  */
4034
  sal = find_pc_line (func_addr, 0);
4035
 
4036
  /* Now sal describes the source line at the function's entry point,
4037
     which (by convention) is the prologue.  The end of that "line",
4038
     sal.end, is the end of the prologue.
4039
 
4040
     Note that, for functions whose source code is all on a single
4041
     line, the line number information doesn't always end up this way.
4042
     So we must verify that our purported end-of-prologue address is
4043
     *within* the function, not at its start or end.  */
4044
  if (sal.line == 0
4045
      || sal.end <= func_addr
4046
      || func_end <= sal.end)
4047
    {
4048
      /* We don't have any good line number info, so use the minsym
4049
         information, together with the architecture-specific prologue
4050
         scanning code.  */
4051
      CORE_ADDR prologue_end = gdbarch_skip_prologue
4052
                                 (current_gdbarch, func_addr);
4053
 
4054
      return func_addr <= pc && pc < prologue_end;
4055
    }
4056
 
4057
  /* We have line number info, and it looks good.  */
4058
  return func_addr <= pc && pc < sal.end;
4059
}
4060
 
4061
/* Given PC at the function's start address, attempt to find the
4062
   prologue end using SAL information.  Return zero if the skip fails.
4063
 
4064
   A non-optimized prologue traditionally has one SAL for the function
4065
   and a second for the function body.  A single line function has
4066
   them both pointing at the same line.
4067
 
4068
   An optimized prologue is similar but the prologue may contain
4069
   instructions (SALs) from the instruction body.  Need to skip those
4070
   while not getting into the function body.
4071
 
4072
   The functions end point and an increasing SAL line are used as
4073
   indicators of the prologue's endpoint.
4074
 
4075
   This code is based on the function refine_prologue_limit (versions
4076
   found in both ia64 and ppc).  */
4077
 
4078
CORE_ADDR
4079
skip_prologue_using_sal (CORE_ADDR func_addr)
4080
{
4081
  struct symtab_and_line prologue_sal;
4082
  CORE_ADDR start_pc;
4083
  CORE_ADDR end_pc;
4084
 
4085
  /* Get an initial range for the function.  */
4086
  find_pc_partial_function (func_addr, NULL, &start_pc, &end_pc);
4087
  start_pc += gdbarch_deprecated_function_start_offset (current_gdbarch);
4088
 
4089
  prologue_sal = find_pc_line (start_pc, 0);
4090
  if (prologue_sal.line != 0)
4091
    {
4092
      /* If there is only one sal that covers the entire function,
4093
         then it is probably a single line function, like
4094
         "foo(){}". */
4095
      if (prologue_sal.end >= end_pc)
4096
        return 0;
4097
      while (prologue_sal.end < end_pc)
4098
        {
4099
          struct symtab_and_line sal;
4100
 
4101
          sal = find_pc_line (prologue_sal.end, 0);
4102
          if (sal.line == 0)
4103
            break;
4104
          /* Assume that a consecutive SAL for the same (or larger)
4105
             line mark the prologue -> body transition.  */
4106
          if (sal.line >= prologue_sal.line)
4107
            break;
4108
          /* The case in which compiler's optimizer/scheduler has
4109
             moved instructions into the prologue.  We look ahead in
4110
             the function looking for address ranges whose
4111
             corresponding line number is less the first one that we
4112
             found for the function.  This is more conservative then
4113
             refine_prologue_limit which scans a large number of SALs
4114
             looking for any in the prologue */
4115
          prologue_sal = sal;
4116
        }
4117
    }
4118
  return prologue_sal.end;
4119
}
4120
 
4121
struct symtabs_and_lines
4122
decode_line_spec (char *string, int funfirstline)
4123
{
4124
  struct symtabs_and_lines sals;
4125
  struct symtab_and_line cursal;
4126
 
4127
  if (string == 0)
4128
    error (_("Empty line specification."));
4129
 
4130
  /* We use whatever is set as the current source line. We do not try
4131
     and get a default  or it will recursively call us! */
4132
  cursal = get_current_source_symtab_and_line ();
4133
 
4134
  sals = decode_line_1 (&string, funfirstline,
4135
                        cursal.symtab, cursal.line,
4136
                        (char ***) NULL, NULL);
4137
 
4138
  if (*string)
4139
    error (_("Junk at end of line specification: %s"), string);
4140
  return sals;
4141
}
4142
 
4143
/* Track MAIN */
4144
static char *name_of_main;
4145
 
4146
void
4147
set_main_name (const char *name)
4148
{
4149
  if (name_of_main != NULL)
4150
    {
4151
      xfree (name_of_main);
4152
      name_of_main = NULL;
4153
    }
4154
  if (name != NULL)
4155
    {
4156
      name_of_main = xstrdup (name);
4157
    }
4158
}
4159
 
4160
/* Deduce the name of the main procedure, and set NAME_OF_MAIN
4161
   accordingly.  */
4162
 
4163
static void
4164
find_main_name (void)
4165
{
4166
  const char *new_main_name;
4167
 
4168
  /* Try to see if the main procedure is in Ada.  */
4169
  /* FIXME: brobecker/2005-03-07: Another way of doing this would
4170
     be to add a new method in the language vector, and call this
4171
     method for each language until one of them returns a non-empty
4172
     name.  This would allow us to remove this hard-coded call to
4173
     an Ada function.  It is not clear that this is a better approach
4174
     at this point, because all methods need to be written in a way
4175
     such that false positives never be returned. For instance, it is
4176
     important that a method does not return a wrong name for the main
4177
     procedure if the main procedure is actually written in a different
4178
     language.  It is easy to guaranty this with Ada, since we use a
4179
     special symbol generated only when the main in Ada to find the name
4180
     of the main procedure. It is difficult however to see how this can
4181
     be guarantied for languages such as C, for instance.  This suggests
4182
     that order of call for these methods becomes important, which means
4183
     a more complicated approach.  */
4184
  new_main_name = ada_main_name ();
4185
  if (new_main_name != NULL)
4186
    {
4187
      set_main_name (new_main_name);
4188
      return;
4189
    }
4190
 
4191
  new_main_name = pascal_main_name ();
4192
  if (new_main_name != NULL)
4193
    {
4194
      set_main_name (new_main_name);
4195
      return;
4196
    }
4197
 
4198
  /* The languages above didn't identify the name of the main procedure.
4199
     Fallback to "main".  */
4200
  set_main_name ("main");
4201
}
4202
 
4203
char *
4204
main_name (void)
4205
{
4206
  if (name_of_main == NULL)
4207
    find_main_name ();
4208
 
4209
  return name_of_main;
4210
}
4211
 
4212
/* Handle ``executable_changed'' events for the symtab module.  */
4213
 
4214
static void
4215
symtab_observer_executable_changed (void *unused)
4216
{
4217
  /* NAME_OF_MAIN may no longer be the same, so reset it for now.  */
4218
  set_main_name (NULL);
4219
}
4220
 
4221
/* Helper to expand_line_sal below.  Appends new sal to SAL,
4222
   initializing it from SYMTAB, LINENO and PC.  */
4223
static void
4224
append_expanded_sal (struct symtabs_and_lines *sal,
4225
                     struct symtab *symtab,
4226
                     int lineno, CORE_ADDR pc)
4227
{
4228
  CORE_ADDR func_addr, func_end;
4229
 
4230
  sal->sals = xrealloc (sal->sals,
4231
                        sizeof (sal->sals[0])
4232
                        * (sal->nelts + 1));
4233
  init_sal (sal->sals + sal->nelts);
4234
  sal->sals[sal->nelts].symtab = symtab;
4235
  sal->sals[sal->nelts].section = NULL;
4236
  sal->sals[sal->nelts].end = 0;
4237
  sal->sals[sal->nelts].line = lineno;
4238
  sal->sals[sal->nelts].pc = pc;
4239
  ++sal->nelts;
4240
}
4241
 
4242
/* Compute a set of all sals in
4243
   the entire program that correspond to same file
4244
   and line as SAL and return those.  If there
4245
   are several sals that belong to the same block,
4246
   only one sal for the block is included in results.  */
4247
 
4248
struct symtabs_and_lines
4249
expand_line_sal (struct symtab_and_line sal)
4250
{
4251
  struct symtabs_and_lines ret, this_line;
4252
  int i, j;
4253
  struct objfile *objfile;
4254
  struct partial_symtab *psymtab;
4255
  struct symtab *symtab;
4256
  int lineno;
4257
  int deleted = 0;
4258
  struct block **blocks = NULL;
4259
  int *filter;
4260
 
4261
  ret.nelts = 0;
4262
  ret.sals = NULL;
4263
 
4264
  if (sal.symtab == NULL || sal.line == 0 || sal.pc != 0)
4265
    {
4266
      ret.sals = xmalloc (sizeof (struct symtab_and_line));
4267
      ret.sals[0] = sal;
4268
      ret.nelts = 1;
4269
      return ret;
4270
    }
4271
  else
4272
    {
4273
      struct linetable_entry *best_item = 0;
4274
      struct symtab *best_symtab = 0;
4275
      int exact = 0;
4276
 
4277
      lineno = sal.line;
4278
 
4279
      /* We meed to find all symtabs for a file which name
4280
         is described by sal. We cannot just directly
4281
         iterate over symtabs, since a symtab might not be
4282
         yet created. We also cannot iterate over psymtabs,
4283
         calling PSYMTAB_TO_SYMTAB and working on that symtab,
4284
         since PSYMTAB_TO_SYMTAB will return NULL for psymtab
4285
         corresponding to an included file. Therefore, we do
4286
         first pass over psymtabs, reading in those with
4287
         the right name.  Then, we iterate over symtabs, knowing
4288
         that all symtabs we're interested in are loaded.  */
4289
 
4290
      ALL_PSYMTABS (objfile, psymtab)
4291
        {
4292
          if (strcmp (sal.symtab->filename,
4293
                      psymtab->filename) == 0)
4294
            PSYMTAB_TO_SYMTAB (psymtab);
4295
        }
4296
 
4297
 
4298
      /* For each symtab, we add all pcs to ret.sals. I'm actually
4299
         not sure what to do if we have exact match in one symtab,
4300
         and non-exact match on another symtab.
4301
      */
4302
      ALL_SYMTABS (objfile, symtab)
4303
        {
4304
          if (strcmp (sal.symtab->filename,
4305
                      symtab->filename) == 0)
4306
            {
4307
              struct linetable *l;
4308
              int len;
4309
              l = LINETABLE (symtab);
4310
              if (!l)
4311
                continue;
4312
              len = l->nitems;
4313
 
4314
              for (j = 0; j < len; j++)
4315
                {
4316
                  struct linetable_entry *item = &(l->item[j]);
4317
 
4318
                  if (item->line == lineno)
4319
                    {
4320
                      exact = 1;
4321
                      append_expanded_sal (&ret, symtab, lineno, item->pc);
4322
                    }
4323
                  else if (!exact && item->line > lineno
4324
                           && (best_item == NULL || item->line < best_item->line))
4325
 
4326
                    {
4327
                      best_item = item;
4328
                      best_symtab = symtab;
4329
                    }
4330
                }
4331
            }
4332
        }
4333
      if (!exact && best_item)
4334
        append_expanded_sal (&ret, best_symtab, lineno, best_item->pc);
4335
    }
4336
 
4337
  /* For optimized code, compiler can scatter one source line accross
4338
     disjoint ranges of PC values, even when no duplicate functions
4339
     or inline functions are involved.  For example, 'for (;;)' inside
4340
     non-template non-inline non-ctor-or-dtor function can result
4341
     in two PC ranges.  In this case, we don't want to set breakpoint
4342
     on first PC of each range.  To filter such cases, we use containing
4343
     blocks -- for each PC found above we see if there are other PCs
4344
     that are in the same block.  If yes, the other PCs are filtered out.  */
4345
 
4346
  filter = xmalloc (ret.nelts * sizeof (int));
4347
  blocks = xmalloc (ret.nelts * sizeof (struct block *));
4348
  for (i = 0; i < ret.nelts; ++i)
4349
    {
4350
      filter[i] = 1;
4351
      blocks[i] = block_for_pc (ret.sals[i].pc);
4352
    }
4353
 
4354
  for (i = 0; i < ret.nelts; ++i)
4355
    if (blocks[i] != NULL)
4356
      for (j = i+1; j < ret.nelts; ++j)
4357
        if (blocks[j] == blocks[i])
4358
          {
4359
            filter[j] = 0;
4360
            ++deleted;
4361
            break;
4362
          }
4363
 
4364
  {
4365
    struct symtab_and_line *final =
4366
      xmalloc (sizeof (struct symtab_and_line) * (ret.nelts-deleted));
4367
 
4368
    for (i = 0, j = 0; i < ret.nelts; ++i)
4369
      if (filter[i])
4370
        final[j++] = ret.sals[i];
4371
 
4372
    ret.nelts -= deleted;
4373
    xfree (ret.sals);
4374
    ret.sals = final;
4375
  }
4376
 
4377
  return ret;
4378
}
4379
 
4380
 
4381
void
4382
_initialize_symtab (void)
4383
{
4384
  add_info ("variables", variables_info, _("\
4385
All global and static variable names, or those matching REGEXP."));
4386
  if (dbx_commands)
4387
    add_com ("whereis", class_info, variables_info, _("\
4388
All global and static variable names, or those matching REGEXP."));
4389
 
4390
  add_info ("functions", functions_info,
4391
            _("All function names, or those matching REGEXP."));
4392
 
4393
 
4394
  /* FIXME:  This command has at least the following problems:
4395
     1.  It prints builtin types (in a very strange and confusing fashion).
4396
     2.  It doesn't print right, e.g. with
4397
     typedef struct foo *FOO
4398
     type_print prints "FOO" when we want to make it (in this situation)
4399
     print "struct foo *".
4400
     I also think "ptype" or "whatis" is more likely to be useful (but if
4401
     there is much disagreement "info types" can be fixed).  */
4402
  add_info ("types", types_info,
4403
            _("All type names, or those matching REGEXP."));
4404
 
4405
  add_info ("sources", sources_info,
4406
            _("Source files in the program."));
4407
 
4408
  add_com ("rbreak", class_breakpoint, rbreak_command,
4409
           _("Set a breakpoint for all functions matching REGEXP."));
4410
 
4411
  if (xdb_commands)
4412
    {
4413
      add_com ("lf", class_info, sources_info,
4414
               _("Source files in the program"));
4415
      add_com ("lg", class_info, variables_info, _("\
4416
All global and static variable names, or those matching REGEXP."));
4417
    }
4418
 
4419
  /* Initialize the one built-in type that isn't language dependent... */
4420
  builtin_type_error = init_type (TYPE_CODE_ERROR, 0, 0,
4421
                                  "<unknown type>", (struct objfile *) NULL);
4422
 
4423
  observer_attach_executable_changed (symtab_observer_executable_changed);
4424
}

powered by: WebSVN 2.1.0

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