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

Subversion Repositories openrisc_me

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

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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