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

Subversion Repositories openrisc_me

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

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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