1 /* Symbol table lookup for the GNU debugger, GDB.
3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
4 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
5 Free Software Foundation, Inc.
7 This file is part of GDB.
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 2 of the License, or
12 (at your option) any later version.
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.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
34 #include "call-cmds.h"
35 #include "gdb_regex.h"
36 #include "expression.h"
42 #include "filenames.h" /* for FILENAME_CMP */
46 #include "gdb_obstack.h"
49 #include <sys/types.h>
51 #include "gdb_string.h"
56 /* Prototypes for local functions */
58 static void completion_list_add_name (char *, char *, int, char *, char *);
60 static void rbreak_command (char *, int);
62 static void types_info (char *, int);
64 static void functions_info (char *, int);
66 static void variables_info (char *, int);
68 static void sources_info (char *, int);
70 static void output_source_filename (char *, int *);
72 static int find_line_common (struct linetable
*, int, int *);
74 /* This one is used by linespec.c */
76 char *operator_chars (char *p
, char **end
);
78 static struct partial_symbol
*lookup_partial_symbol (struct partial_symtab
*,
83 static struct symbol
*lookup_symbol_aux (const char *name
,
84 const char *mangled_name
,
85 const struct block
*block
,
86 const namespace_enum
namespace,
87 int *is_a_field_of_this
,
88 struct symtab
**symtab
);
91 struct symbol
*lookup_symbol_aux_local (const char *name
,
92 const char *mangled_name
,
93 const struct block
*block
,
94 const namespace_enum
namespace,
95 struct symtab
**symtab
,
96 const struct block
**static_block
);
99 struct symbol
*lookup_symbol_aux_block (const char *name
,
100 const char *mangled_name
,
101 const struct block
*block
,
102 const namespace_enum
namespace,
103 struct symtab
**symtab
);
106 struct symbol
*lookup_symbol_aux_symtabs (int block_index
,
108 const char *mangled_name
,
109 const namespace_enum
namespace,
110 struct symtab
**symtab
);
113 struct symbol
*lookup_symbol_aux_psymtabs (int block_index
,
115 const char *mangled_name
,
116 const namespace_enum
namespace,
117 struct symtab
**symtab
);
120 struct symbol
*lookup_symbol_aux_minsyms (const char *name
,
121 const char *mangled_name
,
122 const namespace_enum
namespace,
123 int *is_a_field_of_this
,
124 struct symtab
**symtab
);
126 static struct symbol
*find_active_alias (struct symbol
*sym
, CORE_ADDR addr
);
128 /* This flag is used in hppa-tdep.c, and set in hp-symtab-read.c */
129 /* Signals the presence of objects compiled by HP compilers */
130 int hp_som_som_object_present
= 0;
132 static void fixup_section (struct general_symbol_info
*, struct objfile
*);
134 static int file_matches (char *, char **, int);
136 static void print_symbol_info (namespace_enum
,
137 struct symtab
*, struct symbol
*, int, char *);
139 static void print_msymbol_info (struct minimal_symbol
*);
141 static void symtab_symbol_info (char *, namespace_enum
, int);
143 static void overload_list_add_symbol (struct symbol
*sym
, char *oload_name
);
145 void _initialize_symtab (void);
149 /* The single non-language-specific builtin type */
150 struct type
*builtin_type_error
;
152 /* Block in which the most recently searched-for symbol was found.
153 Might be better to make this a parameter to lookup_symbol and
156 const struct block
*block_found
;
158 /* Check for a symtab of a specific name; first in symtabs, then in
159 psymtabs. *If* there is no '/' in the name, a match after a '/'
160 in the symtab filename will also work. */
163 lookup_symtab (const char *name
)
165 register struct symtab
*s
;
166 register struct partial_symtab
*ps
;
167 register struct objfile
*objfile
;
168 char *real_path
= NULL
;
169 char *full_path
= NULL
;
171 /* Here we are interested in canonicalizing an absolute path, not
172 absolutizing a relative path. */
173 if (IS_ABSOLUTE_PATH (name
))
175 full_path
= xfullpath (name
);
176 make_cleanup (xfree
, full_path
);
177 real_path
= gdb_realpath (name
);
178 make_cleanup (xfree
, real_path
);
183 /* First, search for an exact match */
185 ALL_SYMTABS (objfile
, s
)
187 if (FILENAME_CMP (name
, s
->filename
) == 0)
192 /* If the user gave us an absolute path, try to find the file in
193 this symtab and use its absolute path. */
195 if (full_path
!= NULL
)
197 const char *fp
= symtab_to_filename (s
);
198 if (FILENAME_CMP (full_path
, fp
) == 0)
204 if (real_path
!= NULL
)
206 char *rp
= gdb_realpath (symtab_to_filename (s
));
207 make_cleanup (xfree
, rp
);
208 if (FILENAME_CMP (real_path
, rp
) == 0)
215 /* Now, search for a matching tail (only if name doesn't have any dirs) */
217 if (lbasename (name
) == name
)
218 ALL_SYMTABS (objfile
, s
)
220 if (FILENAME_CMP (lbasename (s
->filename
), name
) == 0)
224 /* Same search rules as above apply here, but now we look thru the
227 ps
= lookup_partial_symtab (name
);
232 error ("Internal: readin %s pst for `%s' found when no symtab found.",
235 s
= PSYMTAB_TO_SYMTAB (ps
);
240 /* At this point, we have located the psymtab for this file, but
241 the conversion to a symtab has failed. This usually happens
242 when we are looking up an include file. In this case,
243 PSYMTAB_TO_SYMTAB doesn't return a symtab, even though one has
244 been created. So, we need to run through the symtabs again in
245 order to find the file.
246 XXX - This is a crock, and should be fixed inside of the the
247 symbol parsing routines. */
251 /* Lookup the partial symbol table of a source file named NAME.
252 *If* there is no '/' in the name, a match after a '/'
253 in the psymtab filename will also work. */
255 struct partial_symtab
*
256 lookup_partial_symtab (const char *name
)
258 register struct partial_symtab
*pst
;
259 register struct objfile
*objfile
;
260 char *full_path
= NULL
;
261 char *real_path
= NULL
;
263 /* Here we are interested in canonicalizing an absolute path, not
264 absolutizing a relative path. */
265 if (IS_ABSOLUTE_PATH (name
))
267 full_path
= xfullpath (name
);
268 make_cleanup (xfree
, full_path
);
269 real_path
= gdb_realpath (name
);
270 make_cleanup (xfree
, real_path
);
273 ALL_PSYMTABS (objfile
, pst
)
275 if (FILENAME_CMP (name
, pst
->filename
) == 0)
280 /* If the user gave us an absolute path, try to find the file in
281 this symtab and use its absolute path. */
282 if (full_path
!= NULL
)
284 if (pst
->fullname
== NULL
)
285 source_full_path_of (pst
->filename
, &pst
->fullname
);
286 if (pst
->fullname
!= NULL
287 && FILENAME_CMP (full_path
, pst
->fullname
) == 0)
293 if (real_path
!= NULL
)
296 if (pst
->fullname
== NULL
)
297 source_full_path_of (pst
->filename
, &pst
->fullname
);
298 if (pst
->fullname
!= NULL
)
300 rp
= gdb_realpath (pst
->fullname
);
301 make_cleanup (xfree
, rp
);
303 if (rp
!= NULL
&& FILENAME_CMP (real_path
, rp
) == 0)
310 /* Now, search for a matching tail (only if name doesn't have any dirs) */
312 if (lbasename (name
) == name
)
313 ALL_PSYMTABS (objfile
, pst
)
315 if (FILENAME_CMP (lbasename (pst
->filename
), name
) == 0)
322 /* Mangle a GDB method stub type. This actually reassembles the pieces of the
323 full method name, which consist of the class name (from T), the unadorned
324 method name from METHOD_ID, and the signature for the specific overload,
325 specified by SIGNATURE_ID. Note that this function is g++ specific. */
328 gdb_mangle_name (struct type
*type
, int method_id
, int signature_id
)
330 int mangled_name_len
;
332 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
333 struct fn_field
*method
= &f
[signature_id
];
334 char *field_name
= TYPE_FN_FIELDLIST_NAME (type
, method_id
);
335 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, signature_id
);
336 char *newname
= type_name_no_tag (type
);
338 /* Does the form of physname indicate that it is the full mangled name
339 of a constructor (not just the args)? */
340 int is_full_physname_constructor
;
343 int is_destructor
= is_destructor_name (physname
);
344 /* Need a new type prefix. */
345 char *const_prefix
= method
->is_const
? "C" : "";
346 char *volatile_prefix
= method
->is_volatile
? "V" : "";
348 int len
= (newname
== NULL
? 0 : strlen (newname
));
350 /* Nothing to do if physname already contains a fully mangled v3 abi name
351 or an operator name. */
352 if ((physname
[0] == '_' && physname
[1] == 'Z')
353 || is_operator_name (field_name
))
354 return xstrdup (physname
);
356 is_full_physname_constructor
= is_constructor_name (physname
);
359 is_full_physname_constructor
|| (newname
&& STREQ (field_name
, newname
));
362 is_destructor
= (strncmp (physname
, "__dt", 4) == 0);
364 if (is_destructor
|| is_full_physname_constructor
)
366 mangled_name
= (char *) xmalloc (strlen (physname
) + 1);
367 strcpy (mangled_name
, physname
);
373 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
375 else if (physname
[0] == 't' || physname
[0] == 'Q')
377 /* The physname for template and qualified methods already includes
379 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
385 sprintf (buf
, "__%s%s%d", const_prefix
, volatile_prefix
, len
);
387 mangled_name_len
= ((is_constructor
? 0 : strlen (field_name
))
388 + strlen (buf
) + len
+ strlen (physname
) + 1);
391 mangled_name
= (char *) xmalloc (mangled_name_len
);
393 mangled_name
[0] = '\0';
395 strcpy (mangled_name
, field_name
);
397 strcat (mangled_name
, buf
);
398 /* If the class doesn't have a name, i.e. newname NULL, then we just
399 mangle it using 0 for the length of the class. Thus it gets mangled
400 as something starting with `::' rather than `classname::'. */
402 strcat (mangled_name
, newname
);
404 strcat (mangled_name
, physname
);
405 return (mangled_name
);
409 /* Initialize the language dependent portion of a symbol
410 depending upon the language for the symbol. */
412 symbol_init_language_specific (struct general_symbol_info
*gsymbol
,
413 enum language language
)
415 gsymbol
->language
= language
;
416 if (gsymbol
->language
== language_cplus
417 || gsymbol
->language
== language_java
418 || gsymbol
->language
== language_objc
)
420 gsymbol
->language_specific
.cplus_specific
.demangled_name
= NULL
;
424 memset (&gsymbol
->language_specific
, 0,
425 sizeof (gsymbol
->language_specific
));
429 /* Functions to initialize a symbol's mangled name. */
431 /* Create the hash table used for demangled names. Each hash entry is
432 a pair of strings; one for the mangled name and one for the demangled
433 name. The entry is hashed via just the mangled name. */
436 create_demangled_names_hash (struct objfile
*objfile
)
438 /* Choose 256 as the starting size of the hash table, somewhat arbitrarily.
439 The hash table code will round this up to the next prime number.
440 Choosing a much larger table size wastes memory, and saves only about
441 1% in symbol reading. */
443 objfile
->demangled_names_hash
= htab_create_alloc_ex
444 (256, htab_hash_string
, (int (*) (const void *, const void *)) streq
,
445 NULL
, objfile
->md
, xmcalloc
, xmfree
);
448 /* Try to determine the demangled name for a symbol, based on the
449 language of that symbol. If the language is set to language_auto,
450 it will attempt to find any demangling algorithm that works and
451 then set the language appropriately. The returned name is allocated
452 by the demangler and should be xfree'd. */
455 symbol_find_demangled_name (struct general_symbol_info
*gsymbol
,
458 char *demangled
= NULL
;
460 if (gsymbol
->language
== language_unknown
)
461 gsymbol
->language
= language_auto
;
462 if (gsymbol
->language
== language_cplus
463 || gsymbol
->language
== language_auto
)
466 cplus_demangle (mangled
, DMGL_PARAMS
| DMGL_ANSI
);
467 if (demangled
!= NULL
)
469 gsymbol
->language
= language_cplus
;
473 if (gsymbol
->language
== language_java
)
476 cplus_demangle (mangled
,
477 DMGL_PARAMS
| DMGL_ANSI
| DMGL_JAVA
);
478 if (demangled
!= NULL
)
480 gsymbol
->language
= language_java
;
487 /* Set both the mangled and demangled (if any) names for GSYMBOL based
488 on LINKAGE_NAME and LEN. The hash table corresponding to OBJFILE
489 is used, and the memory comes from that objfile's symbol_obstack.
490 LINKAGE_NAME is copied, so the pointer can be discarded after
491 calling this function. */
493 /* We have to be careful when dealing with Java names: when we run
494 into a Java minimal symbol, we don't know it's a Java symbol, so it
495 gets demangled as a C++ name. This is unfortunate, but there's not
496 much we can do about it: but when demangling partial symbols and
497 regular symbols, we'd better not reuse the wrong demangled name.
498 (See PR gdb/1039.) We solve this by putting a distinctive prefix
499 on Java names when storing them in the hash table. */
501 /* FIXME: carlton/2003-03-13: This is an unfortunate situation. I
502 don't mind the Java prefix so much: different languages have
503 different demangling requirements, so it's only natural that we
504 need to keep language data around in our demangling cache. But
505 it's not good that the minimal symbol has the wrong demangled name.
506 Unfortunately, I can't think of any easy solution to that
509 #define JAVA_PREFIX "##JAVA$$"
510 #define JAVA_PREFIX_LEN 8
513 symbol_set_names (struct general_symbol_info
*gsymbol
,
514 const char *linkage_name
, int len
, struct objfile
*objfile
)
517 /* A 0-terminated copy of the linkage name. */
518 const char *linkage_name_copy
;
519 /* A copy of the linkage name that might have a special Java prefix
520 added to it, for use when looking names up in the hash table. */
521 const char *lookup_name
;
522 /* The length of lookup_name. */
525 if (objfile
->demangled_names_hash
== NULL
)
526 create_demangled_names_hash (objfile
);
528 /* The stabs reader generally provides names that are not
529 NUL-terminated; most of the other readers don't do this, so we
530 can just use the given copy, unless we're in the Java case. */
531 if (gsymbol
->language
== language_java
)
534 lookup_len
= len
+ JAVA_PREFIX_LEN
;
536 alloc_name
= alloca (lookup_len
+ 1);
537 memcpy (alloc_name
, JAVA_PREFIX
, JAVA_PREFIX_LEN
);
538 memcpy (alloc_name
+ JAVA_PREFIX_LEN
, linkage_name
, len
);
539 alloc_name
[lookup_len
] = '\0';
541 lookup_name
= alloc_name
;
542 linkage_name_copy
= alloc_name
+ JAVA_PREFIX_LEN
;
544 else if (linkage_name
[len
] != '\0')
549 alloc_name
= alloca (lookup_len
+ 1);
550 memcpy (alloc_name
, linkage_name
, len
);
551 alloc_name
[lookup_len
] = '\0';
553 lookup_name
= alloc_name
;
554 linkage_name_copy
= alloc_name
;
559 lookup_name
= linkage_name
;
560 linkage_name_copy
= linkage_name
;
563 slot
= (char **) htab_find_slot (objfile
->demangled_names_hash
,
564 lookup_name
, INSERT
);
566 /* If this name is not in the hash table, add it. */
569 char *demangled_name
= symbol_find_demangled_name (gsymbol
,
571 int demangled_len
= demangled_name
? strlen (demangled_name
) : 0;
573 /* If there is a demangled name, place it right after the mangled name.
574 Otherwise, just place a second zero byte after the end of the mangled
576 *slot
= obstack_alloc (&objfile
->symbol_obstack
,
577 lookup_len
+ demangled_len
+ 2);
578 memcpy (*slot
, lookup_name
, lookup_len
+ 1);
579 if (demangled_name
!= NULL
)
581 memcpy (*slot
+ lookup_len
+ 1, demangled_name
, demangled_len
+ 1);
582 xfree (demangled_name
);
585 (*slot
)[lookup_len
+ 1] = '\0';
588 gsymbol
->name
= *slot
+ lookup_len
- len
;
589 if ((*slot
)[lookup_len
+ 1] != '\0')
590 gsymbol
->language_specific
.cplus_specific
.demangled_name
591 = &(*slot
)[lookup_len
+ 1];
593 gsymbol
->language_specific
.cplus_specific
.demangled_name
= NULL
;
596 /* Initialize the demangled name of GSYMBOL if possible. Any required space
597 to store the name is obtained from the specified obstack. The function
598 symbol_set_names, above, should be used instead where possible for more
599 efficient memory usage. */
602 symbol_init_demangled_name (struct general_symbol_info
*gsymbol
,
603 struct obstack
*obstack
)
605 char *mangled
= gsymbol
->name
;
606 char *demangled
= NULL
;
608 demangled
= symbol_find_demangled_name (gsymbol
, mangled
);
609 if (gsymbol
->language
== language_cplus
610 || gsymbol
->language
== language_java
)
614 gsymbol
->language_specific
.cplus_specific
.demangled_name
615 = obsavestring (demangled
, strlen (demangled
), obstack
);
619 gsymbol
->language_specific
.cplus_specific
.demangled_name
= NULL
;
623 /* Unknown language; just clean up quietly. */
629 /* Return the source code name of a symbol. In languages where
630 demangling is necessary, this is the demangled name. */
633 symbol_natural_name (const struct general_symbol_info
*gsymbol
)
635 if ((gsymbol
->language
== language_cplus
636 || gsymbol
->language
== language_java
637 || gsymbol
->language
== language_objc
)
638 && (gsymbol
->language_specific
.cplus_specific
.demangled_name
!= NULL
))
640 return gsymbol
->language_specific
.cplus_specific
.demangled_name
;
644 return gsymbol
->name
;
648 /* Return the demangled name for a symbol based on the language for
649 that symbol. If no demangled name exists, return NULL. */
651 symbol_demangled_name (struct general_symbol_info
*gsymbol
)
653 if (gsymbol
->language
== language_cplus
654 || gsymbol
->language
== language_java
655 || gsymbol
->language
== language_objc
)
656 return gsymbol
->language_specific
.cplus_specific
.demangled_name
;
662 /* Initialize the structure fields to zero values. */
664 init_sal (struct symtab_and_line
*sal
)
675 /* Find which partial symtab on contains PC and SECTION. Return 0 if none. */
677 struct partial_symtab
*
678 find_pc_sect_psymtab (CORE_ADDR pc
, asection
*section
)
680 register struct partial_symtab
*pst
;
681 register struct objfile
*objfile
;
682 struct minimal_symbol
*msymbol
;
684 /* If we know that this is not a text address, return failure. This is
685 necessary because we loop based on texthigh and textlow, which do
686 not include the data ranges. */
687 msymbol
= lookup_minimal_symbol_by_pc_section (pc
, section
);
689 && (msymbol
->type
== mst_data
690 || msymbol
->type
== mst_bss
691 || msymbol
->type
== mst_abs
692 || msymbol
->type
== mst_file_data
693 || msymbol
->type
== mst_file_bss
))
696 ALL_PSYMTABS (objfile
, pst
)
698 if (pc
>= pst
->textlow
&& pc
< pst
->texthigh
)
700 struct partial_symtab
*tpst
;
702 /* An objfile that has its functions reordered might have
703 many partial symbol tables containing the PC, but
704 we want the partial symbol table that contains the
705 function containing the PC. */
706 if (!(objfile
->flags
& OBJF_REORDERED
) &&
707 section
== 0) /* can't validate section this way */
713 for (tpst
= pst
; tpst
!= NULL
; tpst
= tpst
->next
)
715 if (pc
>= tpst
->textlow
&& pc
< tpst
->texthigh
)
717 struct partial_symbol
*p
;
719 p
= find_pc_sect_psymbol (tpst
, pc
, section
);
721 && SYMBOL_VALUE_ADDRESS (p
)
722 == SYMBOL_VALUE_ADDRESS (msymbol
))
732 /* Find which partial symtab contains PC. Return 0 if none.
733 Backward compatibility, no section */
735 struct partial_symtab
*
736 find_pc_psymtab (CORE_ADDR pc
)
738 return find_pc_sect_psymtab (pc
, find_pc_mapped_section (pc
));
741 /* Find which partial symbol within a psymtab matches PC and SECTION.
742 Return 0 if none. Check all psymtabs if PSYMTAB is 0. */
744 struct partial_symbol
*
745 find_pc_sect_psymbol (struct partial_symtab
*psymtab
, CORE_ADDR pc
,
748 struct partial_symbol
*best
= NULL
, *p
, **pp
;
752 psymtab
= find_pc_sect_psymtab (pc
, section
);
756 /* Cope with programs that start at address 0 */
757 best_pc
= (psymtab
->textlow
!= 0) ? psymtab
->textlow
- 1 : 0;
759 /* Search the global symbols as well as the static symbols, so that
760 find_pc_partial_function doesn't use a minimal symbol and thus
761 cache a bad endaddr. */
762 for (pp
= psymtab
->objfile
->global_psymbols
.list
+ psymtab
->globals_offset
;
763 (pp
- (psymtab
->objfile
->global_psymbols
.list
+ psymtab
->globals_offset
)
764 < psymtab
->n_global_syms
);
768 if (SYMBOL_NAMESPACE (p
) == VAR_NAMESPACE
769 && SYMBOL_CLASS (p
) == LOC_BLOCK
770 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
771 && (SYMBOL_VALUE_ADDRESS (p
) > best_pc
772 || (psymtab
->textlow
== 0
773 && best_pc
== 0 && SYMBOL_VALUE_ADDRESS (p
) == 0)))
775 if (section
) /* match on a specific section */
777 fixup_psymbol_section (p
, psymtab
->objfile
);
778 if (SYMBOL_BFD_SECTION (p
) != section
)
781 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
786 for (pp
= psymtab
->objfile
->static_psymbols
.list
+ psymtab
->statics_offset
;
787 (pp
- (psymtab
->objfile
->static_psymbols
.list
+ psymtab
->statics_offset
)
788 < psymtab
->n_static_syms
);
792 if (SYMBOL_NAMESPACE (p
) == VAR_NAMESPACE
793 && SYMBOL_CLASS (p
) == LOC_BLOCK
794 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
795 && (SYMBOL_VALUE_ADDRESS (p
) > best_pc
796 || (psymtab
->textlow
== 0
797 && best_pc
== 0 && SYMBOL_VALUE_ADDRESS (p
) == 0)))
799 if (section
) /* match on a specific section */
801 fixup_psymbol_section (p
, psymtab
->objfile
);
802 if (SYMBOL_BFD_SECTION (p
) != section
)
805 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
813 /* Find which partial symbol within a psymtab matches PC. Return 0 if none.
814 Check all psymtabs if PSYMTAB is 0. Backwards compatibility, no section. */
816 struct partial_symbol
*
817 find_pc_psymbol (struct partial_symtab
*psymtab
, CORE_ADDR pc
)
819 return find_pc_sect_psymbol (psymtab
, pc
, find_pc_mapped_section (pc
));
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. */
826 fixup_section (struct general_symbol_info
*ginfo
, struct objfile
*objfile
)
828 struct minimal_symbol
*msym
;
829 msym
= lookup_minimal_symbol (ginfo
->name
, NULL
, objfile
);
833 ginfo
->bfd_section
= SYMBOL_BFD_SECTION (msym
);
834 ginfo
->section
= SYMBOL_SECTION (msym
);
839 fixup_symbol_section (struct symbol
*sym
, struct objfile
*objfile
)
844 if (SYMBOL_BFD_SECTION (sym
))
847 fixup_section (&sym
->ginfo
, objfile
);
852 struct partial_symbol
*
853 fixup_psymbol_section (struct partial_symbol
*psym
, struct objfile
*objfile
)
858 if (SYMBOL_BFD_SECTION (psym
))
861 fixup_section (&psym
->ginfo
, objfile
);
866 /* Find the definition for a specified symbol name NAME
867 in namespace NAMESPACE, visible from lexical block BLOCK.
868 Returns the struct symbol pointer, or zero if no symbol is found.
869 If SYMTAB is non-NULL, store the symbol table in which the
870 symbol was found there, or NULL if not found.
871 C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
872 NAME is a field of the current implied argument `this'. If so set
873 *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
874 BLOCK_FOUND is set to the block in which NAME is found (in the case of
875 a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
877 /* This function has a bunch of loops in it and it would seem to be
878 attractive to put in some QUIT's (though I'm not really sure
879 whether it can run long enough to be really important). But there
880 are a few calls for which it would appear to be bad news to quit
881 out of here: find_proc_desc in alpha-tdep.c and mips-tdep.c. (Note
882 that there is C++ code below which can error(), but that probably
883 doesn't affect these calls since they are looking for a known
884 variable and thus can probably assume it will never hit the C++
888 lookup_symbol (const char *name
, const struct block
*block
,
889 const namespace_enum
namespace, int *is_a_field_of_this
,
890 struct symtab
**symtab
)
892 char *demangled_name
= NULL
;
893 const char *modified_name
= NULL
;
894 const char *mangled_name
= NULL
;
895 int needtofreename
= 0;
896 struct symbol
*returnval
;
898 modified_name
= name
;
900 /* If we are using C++ language, demangle the name before doing a lookup, so
901 we can always binary search. */
902 if (current_language
->la_language
== language_cplus
)
904 demangled_name
= cplus_demangle (name
, DMGL_ANSI
| DMGL_PARAMS
);
908 modified_name
= demangled_name
;
913 if (case_sensitivity
== case_sensitive_off
)
919 copy
= (char *) alloca (len
+ 1);
920 for (i
= 0; i
< len
; i
++)
921 copy
[i
] = tolower (name
[i
]);
923 modified_name
= copy
;
926 returnval
= lookup_symbol_aux (modified_name
, mangled_name
, block
,
927 namespace, is_a_field_of_this
, symtab
);
929 xfree (demangled_name
);
934 static struct symbol
*
935 lookup_symbol_aux (const char *name
, const char *mangled_name
,
936 const struct block
*block
, const namespace_enum
namespace,
937 int *is_a_field_of_this
, struct symtab
**symtab
)
940 const struct block
*static_block
;
942 /* Search specified block and its superiors. Don't search
943 STATIC_BLOCK or GLOBAL_BLOCK. */
945 sym
= lookup_symbol_aux_local (name
, mangled_name
, block
, namespace,
946 symtab
, &static_block
);
951 /* NOTE: carlton/2002-11-05: At the time that this code was
952 #ifdeffed out, the value of 'block' was always NULL at this
953 point, hence the bemused comments below. */
955 /* FIXME: this code is never executed--block is always NULL at this
956 point. What is it trying to do, anyway? We already should have
957 checked the STATIC_BLOCK above (it is the superblock of top-level
958 blocks). Why is VAR_NAMESPACE special-cased? */
959 /* Don't need to mess with the psymtabs; if we have a block,
960 that file is read in. If we don't, then we deal later with
961 all the psymtab stuff that needs checking. */
962 /* Note (RT): The following never-executed code looks unnecessary to me also.
963 * If we change the code to use the original (passed-in)
964 * value of 'block', we could cause it to execute, but then what
965 * would it do? The STATIC_BLOCK of the symtab containing the passed-in
966 * 'block' was already searched by the above code. And the STATIC_BLOCK's
967 * of *other* symtabs (those files not containing 'block' lexically)
968 * should not contain 'block' address-wise. So we wouldn't expect this
969 * code to find any 'sym''s that were not found above. I vote for
970 * deleting the following paragraph of code.
972 if (namespace == VAR_NAMESPACE
&& block
!= NULL
)
975 /* Find the right symtab. */
976 ALL_SYMTABS (objfile
, s
)
978 bv
= BLOCKVECTOR (s
);
979 b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
980 if (BLOCK_START (b
) <= BLOCK_START (block
)
981 && BLOCK_END (b
) > BLOCK_START (block
))
983 sym
= lookup_block_symbol (b
, name
, mangled_name
, VAR_NAMESPACE
);
989 return fixup_symbol_section (sym
, objfile
);
996 /* C++: If requested to do so by the caller,
997 check to see if NAME is a field of `this'. */
998 if (is_a_field_of_this
)
1000 struct value
*v
= value_of_this (0);
1002 *is_a_field_of_this
= 0;
1003 if (v
&& check_field (v
, name
))
1005 *is_a_field_of_this
= 1;
1012 /* If there's a static block to search, search it next. */
1014 /* NOTE: carlton/2002-12-05: There is a question as to whether or
1015 not it would be appropriate to search the current global block
1016 here as well. (That's what this code used to do before the
1017 is_a_field_of_this check was moved up.) On the one hand, it's
1018 redundant with the lookup_symbol_aux_symtabs search that happens
1019 next. On the other hand, if decode_line_1 is passed an argument
1020 like filename:var, then the user presumably wants 'var' to be
1021 searched for in filename. On the third hand, there shouldn't be
1022 multiple global variables all of which are named 'var', and it's
1023 not like decode_line_1 has ever restricted its search to only
1024 global variables in a single filename. All in all, only
1025 searching the static block here seems best: it's correct and it's
1028 /* NOTE: carlton/2002-12-05: There's also a possible performance
1029 issue here: if you usually search for global symbols in the
1030 current file, then it would be slightly better to search the
1031 current global block before searching all the symtabs. But there
1032 are other factors that have a much greater effect on performance
1033 than that one, so I don't think we should worry about that for
1036 if (static_block
!= NULL
)
1038 sym
= lookup_symbol_aux_block (name
, mangled_name
, static_block
,
1044 /* Now search all global blocks. Do the symtab's first, then
1045 check the psymtab's. If a psymtab indicates the existence
1046 of the desired name as a global, then do psymtab-to-symtab
1047 conversion on the fly and return the found symbol. */
1049 sym
= lookup_symbol_aux_symtabs (GLOBAL_BLOCK
, name
, mangled_name
,
1056 /* Check for the possibility of the symbol being a function or
1057 a mangled variable that is stored in one of the minimal symbol tables.
1058 Eventually, all global symbols might be resolved in this way. */
1060 sym
= lookup_symbol_aux_minsyms (name
, mangled_name
,
1061 namespace, is_a_field_of_this
,
1069 sym
= lookup_symbol_aux_psymtabs (GLOBAL_BLOCK
, name
, mangled_name
,
1074 /* Now search all static file-level symbols. Not strictly correct,
1075 but more useful than an error. Do the symtabs first, then check
1076 the psymtabs. If a psymtab indicates the existence of the
1077 desired name as a file-level static, then do psymtab-to-symtab
1078 conversion on the fly and return the found symbol. */
1080 sym
= lookup_symbol_aux_symtabs (STATIC_BLOCK
, name
, mangled_name
,
1085 sym
= lookup_symbol_aux_psymtabs (STATIC_BLOCK
, name
, mangled_name
,
1092 /* Check for the possibility of the symbol being a function or
1093 a global variable that is stored in one of the minimal symbol tables.
1094 The "minimal symbol table" is built from linker-supplied info.
1096 RT: I moved this check to last, after the complete search of
1097 the global (p)symtab's and static (p)symtab's. For HP-generated
1098 symbol tables, this check was causing a premature exit from
1099 lookup_symbol with NULL return, and thus messing up symbol lookups
1100 of things like "c::f". It seems to me a check of the minimal
1101 symbol table ought to be a last resort in any case. I'm vaguely
1102 worried about the comment below which talks about FORTRAN routines "foo_"
1103 though... is it saying we need to do the "minsym" check before
1104 the static check in this case?
1108 sym
= lookup_symbol_aux_minsyms (name
, mangled_name
,
1109 namespace, is_a_field_of_this
,
1122 /* Check to see if the symbol is defined in BLOCK or its superiors.
1123 Don't search STATIC_BLOCK or GLOBAL_BLOCK. If we don't find a
1124 match, store the address of STATIC_BLOCK in static_block. */
1126 static struct symbol
*
1127 lookup_symbol_aux_local (const char *name
, const char *mangled_name
,
1128 const struct block
*block
,
1129 const namespace_enum
namespace,
1130 struct symtab
**symtab
,
1131 const struct block
**static_block
)
1135 /* Check if either no block is specified or it's a global block. */
1137 if (block
== NULL
|| BLOCK_SUPERBLOCK (block
) == NULL
)
1139 *static_block
= NULL
;
1143 while (BLOCK_SUPERBLOCK (BLOCK_SUPERBLOCK (block
)) != NULL
)
1145 sym
= lookup_symbol_aux_block (name
, mangled_name
, block
, namespace,
1149 block
= BLOCK_SUPERBLOCK (block
);
1152 /* We've reached the static block. */
1154 *static_block
= block
;
1158 /* Look up a symbol in a block; if found, locate its symtab, fixup the
1159 symbol, and set block_found appropriately. */
1161 static struct symbol
*
1162 lookup_symbol_aux_block (const char *name
, const char *mangled_name
,
1163 const struct block
*block
,
1164 const namespace_enum
namespace,
1165 struct symtab
**symtab
)
1168 struct objfile
*objfile
= NULL
;
1169 struct blockvector
*bv
;
1171 struct symtab
*s
= NULL
;
1173 sym
= lookup_block_symbol (block
, name
, mangled_name
, namespace);
1176 block_found
= block
;
1179 /* Search the list of symtabs for one which contains the
1180 address of the start of this block. */
1181 ALL_SYMTABS (objfile
, s
)
1183 bv
= BLOCKVECTOR (s
);
1184 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1185 if (BLOCK_START (b
) <= BLOCK_START (block
)
1186 && BLOCK_END (b
) > BLOCK_START (block
))
1193 return fixup_symbol_section (sym
, objfile
);
1199 /* Check to see if the symbol is defined in one of the symtabs.
1200 BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
1201 depending on whether or not we want to search global symbols or
1204 static struct symbol
*
1205 lookup_symbol_aux_symtabs (int block_index
,
1206 const char *name
, const char *mangled_name
,
1207 const namespace_enum
namespace,
1208 struct symtab
**symtab
)
1211 struct objfile
*objfile
;
1212 struct blockvector
*bv
;
1213 const struct block
*block
;
1216 ALL_SYMTABS (objfile
, s
)
1218 bv
= BLOCKVECTOR (s
);
1219 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
1220 sym
= lookup_block_symbol (block
, name
, mangled_name
, namespace);
1223 block_found
= block
;
1226 return fixup_symbol_section (sym
, objfile
);
1233 /* Check to see if the symbol is defined in one of the partial
1234 symtabs. BLOCK_INDEX should be either GLOBAL_BLOCK or
1235 STATIC_BLOCK, depending on whether or not we want to search global
1236 symbols or static symbols. */
1238 static struct symbol
*
1239 lookup_symbol_aux_psymtabs (int block_index
, const char *name
,
1240 const char *mangled_name
,
1241 const namespace_enum
namespace,
1242 struct symtab
**symtab
)
1245 struct objfile
*objfile
;
1246 struct blockvector
*bv
;
1247 const struct block
*block
;
1248 struct partial_symtab
*ps
;
1250 const int psymtab_index
= (block_index
== GLOBAL_BLOCK
? 1 : 0);
1252 ALL_PSYMTABS (objfile
, ps
)
1255 && lookup_partial_symbol (ps
, name
, mangled_name
,
1256 psymtab_index
, namespace))
1258 s
= PSYMTAB_TO_SYMTAB (ps
);
1259 bv
= BLOCKVECTOR (s
);
1260 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
1261 sym
= lookup_block_symbol (block
, name
, mangled_name
, namespace);
1264 /* This shouldn't be necessary, but as a last resort try
1265 looking in the statics even though the psymtab claimed
1266 the symbol was global, or vice-versa. It's possible
1267 that the psymtab gets it wrong in some cases. */
1269 /* FIXME: carlton/2002-09-30: Should we really do that?
1270 If that happens, isn't it likely to be a GDB error, in
1271 which case we should fix the GDB error rather than
1272 silently dealing with it here? So I'd vote for
1273 removing the check for the symbol in the other
1275 block
= BLOCKVECTOR_BLOCK (bv
,
1276 block_index
== GLOBAL_BLOCK
?
1277 STATIC_BLOCK
: GLOBAL_BLOCK
);
1278 sym
= lookup_block_symbol (block
, name
, mangled_name
, namespace);
1280 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>).",
1281 block_index
== GLOBAL_BLOCK
? "global" : "static",
1282 name
, ps
->filename
, name
, name
);
1286 return fixup_symbol_section (sym
, objfile
);
1293 /* Check for the possibility of the symbol being a function or a
1294 mangled variable that is stored in one of the minimal symbol
1295 tables. Eventually, all global symbols might be resolved in this
1298 /* NOTE: carlton/2002-12-05: At one point, this function was part of
1299 lookup_symbol_aux, and what are now 'return' statements within
1300 lookup_symbol_aux_minsyms returned from lookup_symbol_aux, even if
1301 sym was NULL. As far as I can tell, this was basically accidental;
1302 it didn't happen every time that msymbol was non-NULL, but only if
1303 some additional conditions held as well, and it caused problems
1304 with HP-generated symbol tables. */
1306 static struct symbol
*
1307 lookup_symbol_aux_minsyms (const char *name
,
1308 const char *mangled_name
,
1309 const namespace_enum
namespace,
1310 int *is_a_field_of_this
,
1311 struct symtab
**symtab
)
1314 struct blockvector
*bv
;
1315 const struct block
*block
;
1316 struct minimal_symbol
*msymbol
;
1319 if (namespace == VAR_NAMESPACE
)
1321 msymbol
= lookup_minimal_symbol (name
, NULL
, NULL
);
1323 if (msymbol
!= NULL
)
1325 /* OK, we found a minimal symbol in spite of not finding any
1326 symbol. There are various possible explanations for
1327 this. One possibility is the symbol exists in code not
1328 compiled -g. Another possibility is that the 'psymtab'
1329 isn't doing its job. A third possibility, related to #2,
1330 is that we were confused by name-mangling. For instance,
1331 maybe the psymtab isn't doing its job because it only
1332 know about demangled names, but we were given a mangled
1335 /* We first use the address in the msymbol to try to locate
1336 the appropriate symtab. Note that find_pc_sect_symtab()
1337 has a side-effect of doing psymtab-to-symtab expansion,
1338 for the found symtab. */
1339 s
= find_pc_sect_symtab (SYMBOL_VALUE_ADDRESS (msymbol
),
1340 SYMBOL_BFD_SECTION (msymbol
));
1343 /* This is a function which has a symtab for its address. */
1344 bv
= BLOCKVECTOR (s
);
1345 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1347 /* This call used to pass `DEPRECATED_SYMBOL_NAME (msymbol)' as the
1348 `name' argument to lookup_block_symbol. But the name
1349 of a minimal symbol is always mangled, so that seems
1350 to be clearly the wrong thing to pass as the
1353 lookup_block_symbol (block
, name
, mangled_name
, namespace);
1354 /* We kept static functions in minimal symbol table as well as
1355 in static scope. We want to find them in the symbol table. */
1358 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1359 sym
= lookup_block_symbol (block
, name
,
1360 mangled_name
, namespace);
1363 /* NOTE: carlton/2002-12-04: The following comment was
1364 taken from a time when two versions of this function
1365 were part of the body of lookup_symbol_aux: this
1366 comment was taken from the version of the function
1367 that was #ifdef HPUXHPPA, and the comment was right
1368 before the 'return NULL' part of lookup_symbol_aux.
1369 (Hence the "Fall through and return 0" comment.)
1370 Elena did some digging into the situation for
1371 Fortran, and she reports:
1373 "I asked around (thanks to Jeff Knaggs), and I think
1374 the story for Fortran goes like this:
1376 "Apparently, in older Fortrans, '_' was not part of
1377 the user namespace. g77 attached a final '_' to
1378 procedure names as the exported symbols for linkage
1379 (foo_) , but the symbols went in the debug info just
1380 like 'foo'. The rationale behind this is not
1381 completely clear, and maybe it was done to other
1382 symbols as well, not just procedures." */
1384 /* If we get here with sym == 0, the symbol was
1385 found in the minimal symbol table
1386 but not in the symtab.
1387 Fall through and return 0 to use the msymbol
1388 definition of "foo_".
1389 (Note that outer code generally follows up a call
1390 to this routine with a call to lookup_minimal_symbol(),
1391 so a 0 return means we'll just flow into that other routine).
1393 This happens for Fortran "foo_" symbols,
1394 which are "foo" in the symtab.
1396 This can also happen if "asm" is used to make a
1397 regular symbol but not a debugging symbol, e.g.
1398 asm(".globl _main");
1402 if (symtab
!= NULL
&& sym
!= NULL
)
1404 return fixup_symbol_section (sym
, s
->objfile
);
1406 else if (MSYMBOL_TYPE (msymbol
) != mst_text
1407 && MSYMBOL_TYPE (msymbol
) != mst_file_text
1408 && !STREQ (name
, DEPRECATED_SYMBOL_NAME (msymbol
)))
1410 /* This is a mangled variable, look it up by its
1412 return lookup_symbol_aux (DEPRECATED_SYMBOL_NAME (msymbol
), mangled_name
,
1413 NULL
, namespace, is_a_field_of_this
,
1422 /* Look, in partial_symtab PST, for symbol whose natural name is NAME.
1423 If LINKAGE_NAME is non-NULL, check in addition that the symbol's
1424 linkage name matches it. Check the global symbols if GLOBAL, the
1425 static symbols if not */
1427 static struct partial_symbol
*
1428 lookup_partial_symbol (struct partial_symtab
*pst
, const char *name
,
1429 const char *linkage_name
, int global
,
1430 namespace_enum
namespace)
1432 struct partial_symbol
*temp
;
1433 struct partial_symbol
**start
, **psym
;
1434 struct partial_symbol
**top
, **real_top
, **bottom
, **center
;
1435 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
1436 int do_linear_search
= 1;
1443 pst
->objfile
->global_psymbols
.list
+ pst
->globals_offset
:
1444 pst
->objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1446 if (global
) /* This means we can use a binary search. */
1448 do_linear_search
= 0;
1450 /* Binary search. This search is guaranteed to end with center
1451 pointing at the earliest partial symbol whose name might be
1452 correct. At that point *all* partial symbols with an
1453 appropriate name will be checked against the correct
1457 top
= start
+ length
- 1;
1459 while (top
> bottom
)
1461 center
= bottom
+ (top
- bottom
) / 2;
1462 if (!(center
< top
))
1463 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
1464 if (!do_linear_search
1465 && (SYMBOL_LANGUAGE (*center
) == language_java
))
1467 do_linear_search
= 1;
1469 if (strcmp_iw_ordered (SYMBOL_NATURAL_NAME (*center
), name
) >= 0)
1475 bottom
= center
+ 1;
1478 if (!(top
== bottom
))
1479 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
1481 while (top
<= real_top
1482 && (linkage_name
!= NULL
1483 ? strcmp (SYMBOL_LINKAGE_NAME (*top
), linkage_name
) == 0
1484 : SYMBOL_MATCHES_NATURAL_NAME (*top
,name
)))
1486 if (SYMBOL_NAMESPACE (*top
) == namespace)
1494 /* Can't use a binary search or else we found during the binary search that
1495 we should also do a linear search. */
1497 if (do_linear_search
)
1499 for (psym
= start
; psym
< start
+ length
; psym
++)
1501 if (namespace == SYMBOL_NAMESPACE (*psym
))
1503 if (linkage_name
!= NULL
1504 ? strcmp (SYMBOL_LINKAGE_NAME (*psym
), linkage_name
) == 0
1505 : SYMBOL_MATCHES_NATURAL_NAME (*psym
, name
))
1516 /* Look up a type named NAME in the struct_namespace. The type returned
1517 must not be opaque -- i.e., must have at least one field defined
1519 This code was modelled on lookup_symbol -- the parts not relevant to looking
1520 up types were just left out. In particular it's assumed here that types
1521 are available in struct_namespace and only at file-static or global blocks. */
1525 lookup_transparent_type (const char *name
)
1527 register struct symbol
*sym
;
1528 register struct symtab
*s
= NULL
;
1529 register struct partial_symtab
*ps
;
1530 struct blockvector
*bv
;
1531 register struct objfile
*objfile
;
1532 register struct block
*block
;
1534 /* Now search all the global symbols. Do the symtab's first, then
1535 check the psymtab's. If a psymtab indicates the existence
1536 of the desired name as a global, then do psymtab-to-symtab
1537 conversion on the fly and return the found symbol. */
1539 ALL_SYMTABS (objfile
, s
)
1541 bv
= BLOCKVECTOR (s
);
1542 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1543 sym
= lookup_block_symbol (block
, name
, NULL
, STRUCT_NAMESPACE
);
1544 if (sym
&& !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1546 return SYMBOL_TYPE (sym
);
1550 ALL_PSYMTABS (objfile
, ps
)
1552 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, NULL
,
1553 1, STRUCT_NAMESPACE
))
1555 s
= PSYMTAB_TO_SYMTAB (ps
);
1556 bv
= BLOCKVECTOR (s
);
1557 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1558 sym
= lookup_block_symbol (block
, name
, NULL
, STRUCT_NAMESPACE
);
1561 /* This shouldn't be necessary, but as a last resort
1562 * try looking in the statics even though the psymtab
1563 * claimed the symbol was global. It's possible that
1564 * the psymtab gets it wrong in some cases.
1566 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1567 sym
= lookup_block_symbol (block
, name
, NULL
, STRUCT_NAMESPACE
);
1569 error ("Internal: global symbol `%s' found in %s psymtab but not in symtab.\n\
1570 %s may be an inlined function, or may be a template function\n\
1571 (if a template, try specifying an instantiation: %s<type>).",
1572 name
, ps
->filename
, name
, name
);
1574 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1575 return SYMBOL_TYPE (sym
);
1579 /* Now search the static file-level symbols.
1580 Not strictly correct, but more useful than an error.
1581 Do the symtab's first, then
1582 check the psymtab's. If a psymtab indicates the existence
1583 of the desired name as a file-level static, then do psymtab-to-symtab
1584 conversion on the fly and return the found symbol.
1587 ALL_SYMTABS (objfile
, s
)
1589 bv
= BLOCKVECTOR (s
);
1590 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1591 sym
= lookup_block_symbol (block
, name
, NULL
, STRUCT_NAMESPACE
);
1592 if (sym
&& !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1594 return SYMBOL_TYPE (sym
);
1598 ALL_PSYMTABS (objfile
, ps
)
1600 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, NULL
, 0, STRUCT_NAMESPACE
))
1602 s
= PSYMTAB_TO_SYMTAB (ps
);
1603 bv
= BLOCKVECTOR (s
);
1604 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1605 sym
= lookup_block_symbol (block
, name
, NULL
, STRUCT_NAMESPACE
);
1608 /* This shouldn't be necessary, but as a last resort
1609 * try looking in the globals even though the psymtab
1610 * claimed the symbol was static. It's possible that
1611 * the psymtab gets it wrong in some cases.
1613 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1614 sym
= lookup_block_symbol (block
, name
, NULL
, STRUCT_NAMESPACE
);
1616 error ("Internal: static symbol `%s' found in %s psymtab but not in symtab.\n\
1617 %s may be an inlined function, or may be a template function\n\
1618 (if a template, try specifying an instantiation: %s<type>).",
1619 name
, ps
->filename
, name
, name
);
1621 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1622 return SYMBOL_TYPE (sym
);
1625 return (struct type
*) 0;
1629 /* Find the psymtab containing main(). */
1630 /* FIXME: What about languages without main() or specially linked
1631 executables that have no main() ? */
1633 struct partial_symtab
*
1634 find_main_psymtab (void)
1636 register struct partial_symtab
*pst
;
1637 register struct objfile
*objfile
;
1639 ALL_PSYMTABS (objfile
, pst
)
1641 if (lookup_partial_symbol (pst
, main_name (), NULL
, 1, VAR_NAMESPACE
))
1649 /* Search BLOCK for symbol NAME in NAMESPACE.
1651 Note that if NAME is the demangled form of a C++ symbol, we will fail
1652 to find a match during the binary search of the non-encoded names, but
1653 for now we don't worry about the slight inefficiency of looking for
1654 a match we'll never find, since it will go pretty quick. Once the
1655 binary search terminates, we drop through and do a straight linear
1656 search on the symbols. Each symbol which is marked as being a C++
1657 symbol (language_cplus set) has both the encoded and non-encoded names
1660 If MANGLED_NAME is non-NULL, verify that any symbol we find has this
1661 particular mangled name.
1665 lookup_block_symbol (register const struct block
*block
, const char *name
,
1666 const char *mangled_name
,
1667 const namespace_enum
namespace)
1669 register int bot
, top
, inc
;
1670 register struct symbol
*sym
;
1671 register struct symbol
*sym_found
= NULL
;
1672 register int do_linear_search
= 1;
1674 if (BLOCK_HASHTABLE (block
))
1676 unsigned int hash_index
;
1677 hash_index
= msymbol_hash_iw (name
);
1678 hash_index
= hash_index
% BLOCK_BUCKETS (block
);
1679 for (sym
= BLOCK_BUCKET (block
, hash_index
); sym
; sym
= sym
->hash_next
)
1681 if (SYMBOL_NAMESPACE (sym
) == namespace
1683 ? strcmp (DEPRECATED_SYMBOL_NAME (sym
), mangled_name
) == 0
1684 : SYMBOL_MATCHES_NATURAL_NAME (sym
, name
)))
1690 /* If the blocks's symbols were sorted, start with a binary search. */
1692 if (BLOCK_SHOULD_SORT (block
))
1694 /* Reset the linear search flag so if the binary search fails, we
1695 won't do the linear search once unless we find some reason to
1698 do_linear_search
= 0;
1699 top
= BLOCK_NSYMS (block
);
1702 /* Advance BOT to not far before the first symbol whose name is NAME. */
1706 inc
= (top
- bot
+ 1);
1707 /* No need to keep binary searching for the last few bits worth. */
1712 inc
= (inc
>> 1) + bot
;
1713 sym
= BLOCK_SYM (block
, inc
);
1714 if (!do_linear_search
&& (SYMBOL_LANGUAGE (sym
) == language_java
))
1716 do_linear_search
= 1;
1718 if (SYMBOL_NATURAL_NAME (sym
)[0] < name
[0])
1722 else if (SYMBOL_NATURAL_NAME (sym
)[0] > name
[0])
1726 else if (strcmp (SYMBOL_NATURAL_NAME (sym
), name
) < 0)
1736 /* Now scan forward until we run out of symbols, find one whose
1737 name is greater than NAME, or find one we want. If there is
1738 more than one symbol with the right name and namespace, we
1739 return the first one; I believe it is now impossible for us
1740 to encounter two symbols with the same name and namespace
1741 here, because blocks containing argument symbols are no
1742 longer sorted. The exception is for C++, where multiple functions
1743 (cloned constructors / destructors, in particular) can have
1744 the same demangled name. So if we have a particular
1745 mangled name to match, try to do so. */
1747 top
= BLOCK_NSYMS (block
);
1750 sym
= BLOCK_SYM (block
, bot
);
1751 if (SYMBOL_NAMESPACE (sym
) == namespace
1753 ? strcmp (DEPRECATED_SYMBOL_NAME (sym
), mangled_name
) == 0
1754 : SYMBOL_MATCHES_NATURAL_NAME (sym
, name
)))
1758 if (SYMBOL_PRINT_NAME (sym
)[0] > name
[0])
1766 /* Here if block isn't sorted, or we fail to find a match during the
1767 binary search above. If during the binary search above, we find a
1768 symbol which is a Java symbol, then we have re-enabled the linear
1769 search flag which was reset when starting the binary search.
1771 This loop is equivalent to the loop above, but hacked greatly for speed.
1773 Note that parameter symbols do not always show up last in the
1774 list; this loop makes sure to take anything else other than
1775 parameter symbols first; it only uses parameter symbols as a
1776 last resort. Note that this only takes up extra computation
1779 if (do_linear_search
)
1781 top
= BLOCK_NSYMS (block
);
1785 sym
= BLOCK_SYM (block
, bot
);
1786 if (SYMBOL_NAMESPACE (sym
) == namespace
1788 ? strcmp (DEPRECATED_SYMBOL_NAME (sym
), mangled_name
) == 0
1789 : SYMBOL_MATCHES_NATURAL_NAME (sym
, name
)))
1791 /* If SYM has aliases, then use any alias that is active
1792 at the current PC. If no alias is active at the current
1793 PC, then use the main symbol.
1795 ?!? Is checking the current pc correct? Is this routine
1796 ever called to look up a symbol from another context?
1798 FIXME: No, it's not correct. If someone sets a
1799 conditional breakpoint at an address, then the
1800 breakpoint's `struct expression' should refer to the
1801 `struct symbol' appropriate for the breakpoint's
1802 address, which may not be the PC.
1804 Even if it were never called from another context,
1805 it's totally bizarre for lookup_symbol's behavior to
1806 depend on the value of the inferior's current PC. We
1807 should pass in the appropriate PC as well as the
1808 block. The interface to lookup_symbol should change
1809 to require the caller to provide a PC. */
1811 if (SYMBOL_ALIASES (sym
))
1812 sym
= find_active_alias (sym
, read_pc ());
1815 if (SYMBOL_CLASS (sym
) != LOC_ARG
&&
1816 SYMBOL_CLASS (sym
) != LOC_LOCAL_ARG
&&
1817 SYMBOL_CLASS (sym
) != LOC_REF_ARG
&&
1818 SYMBOL_CLASS (sym
) != LOC_REGPARM
&&
1819 SYMBOL_CLASS (sym
) != LOC_REGPARM_ADDR
&&
1820 SYMBOL_CLASS (sym
) != LOC_BASEREG_ARG
&&
1821 SYMBOL_CLASS (sym
) != LOC_COMPUTED_ARG
)
1829 return (sym_found
); /* Will be NULL if not found. */
1832 /* Given a main symbol SYM and ADDR, search through the alias
1833 list to determine if an alias is active at ADDR and return
1836 If no alias is active, then return SYM. */
1838 static struct symbol
*
1839 find_active_alias (struct symbol
*sym
, CORE_ADDR addr
)
1841 struct range_list
*r
;
1842 struct alias_list
*aliases
;
1844 /* If we have aliases, check them first. */
1845 aliases
= SYMBOL_ALIASES (sym
);
1849 if (!SYMBOL_RANGES (aliases
->sym
))
1850 return aliases
->sym
;
1851 for (r
= SYMBOL_RANGES (aliases
->sym
); r
; r
= r
->next
)
1853 if (r
->start
<= addr
&& r
->end
> addr
)
1854 return aliases
->sym
;
1856 aliases
= aliases
->next
;
1859 /* Nothing found, return the main symbol. */
1864 /* Find the symtab associated with PC and SECTION. Look through the
1865 psymtabs and read in another symtab if necessary. */
1868 find_pc_sect_symtab (CORE_ADDR pc
, asection
*section
)
1870 register struct block
*b
;
1871 struct blockvector
*bv
;
1872 register struct symtab
*s
= NULL
;
1873 register struct symtab
*best_s
= NULL
;
1874 register struct partial_symtab
*ps
;
1875 register struct objfile
*objfile
;
1876 CORE_ADDR distance
= 0;
1877 struct minimal_symbol
*msymbol
;
1879 /* If we know that this is not a text address, return failure. This is
1880 necessary because we loop based on the block's high and low code
1881 addresses, which do not include the data ranges, and because
1882 we call find_pc_sect_psymtab which has a similar restriction based
1883 on the partial_symtab's texthigh and textlow. */
1884 msymbol
= lookup_minimal_symbol_by_pc_section (pc
, section
);
1886 && (msymbol
->type
== mst_data
1887 || msymbol
->type
== mst_bss
1888 || msymbol
->type
== mst_abs
1889 || msymbol
->type
== mst_file_data
1890 || msymbol
->type
== mst_file_bss
))
1893 /* Search all symtabs for the one whose file contains our address, and which
1894 is the smallest of all the ones containing the address. This is designed
1895 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
1896 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
1897 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
1899 This happens for native ecoff format, where code from included files
1900 gets its own symtab. The symtab for the included file should have
1901 been read in already via the dependency mechanism.
1902 It might be swifter to create several symtabs with the same name
1903 like xcoff does (I'm not sure).
1905 It also happens for objfiles that have their functions reordered.
1906 For these, the symtab we are looking for is not necessarily read in. */
1908 ALL_SYMTABS (objfile
, s
)
1910 bv
= BLOCKVECTOR (s
);
1911 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1913 if (BLOCK_START (b
) <= pc
1914 && BLOCK_END (b
) > pc
1916 || BLOCK_END (b
) - BLOCK_START (b
) < distance
))
1918 /* For an objfile that has its functions reordered,
1919 find_pc_psymtab will find the proper partial symbol table
1920 and we simply return its corresponding symtab. */
1921 /* In order to better support objfiles that contain both
1922 stabs and coff debugging info, we continue on if a psymtab
1924 if ((objfile
->flags
& OBJF_REORDERED
) && objfile
->psymtabs
)
1926 ps
= find_pc_sect_psymtab (pc
, section
);
1928 return PSYMTAB_TO_SYMTAB (ps
);
1933 struct symbol
*sym
= NULL
;
1935 ALL_BLOCK_SYMBOLS (b
, i
, sym
)
1937 fixup_symbol_section (sym
, objfile
);
1938 if (section
== SYMBOL_BFD_SECTION (sym
))
1941 if ((i
>= BLOCK_BUCKETS (b
)) && (sym
== NULL
))
1942 continue; /* no symbol in this symtab matches section */
1944 distance
= BLOCK_END (b
) - BLOCK_START (b
);
1953 ps
= find_pc_sect_psymtab (pc
, section
);
1957 /* Might want to error() here (in case symtab is corrupt and
1958 will cause a core dump), but maybe we can successfully
1959 continue, so let's not. */
1961 (Internal error: pc 0x%s in read in psymtab, but not in symtab.)\n",
1963 s
= PSYMTAB_TO_SYMTAB (ps
);
1968 /* Find the symtab associated with PC. Look through the psymtabs and
1969 read in another symtab if necessary. Backward compatibility, no section */
1972 find_pc_symtab (CORE_ADDR pc
)
1974 return find_pc_sect_symtab (pc
, find_pc_mapped_section (pc
));
1978 /* Find the source file and line number for a given PC value and SECTION.
1979 Return a structure containing a symtab pointer, a line number,
1980 and a pc range for the entire source line.
1981 The value's .pc field is NOT the specified pc.
1982 NOTCURRENT nonzero means, if specified pc is on a line boundary,
1983 use the line that ends there. Otherwise, in that case, the line
1984 that begins there is used. */
1986 /* The big complication here is that a line may start in one file, and end just
1987 before the start of another file. This usually occurs when you #include
1988 code in the middle of a subroutine. To properly find the end of a line's PC
1989 range, we must search all symtabs associated with this compilation unit, and
1990 find the one whose first PC is closer than that of the next line in this
1993 /* If it's worth the effort, we could be using a binary search. */
1995 struct symtab_and_line
1996 find_pc_sect_line (CORE_ADDR pc
, struct sec
*section
, int notcurrent
)
1999 register struct linetable
*l
;
2002 register struct linetable_entry
*item
;
2003 struct symtab_and_line val
;
2004 struct blockvector
*bv
;
2005 struct minimal_symbol
*msymbol
;
2006 struct minimal_symbol
*mfunsym
;
2008 /* Info on best line seen so far, and where it starts, and its file. */
2010 struct linetable_entry
*best
= NULL
;
2011 CORE_ADDR best_end
= 0;
2012 struct symtab
*best_symtab
= 0;
2014 /* Store here the first line number
2015 of a file which contains the line at the smallest pc after PC.
2016 If we don't find a line whose range contains PC,
2017 we will use a line one less than this,
2018 with a range from the start of that file to the first line's pc. */
2019 struct linetable_entry
*alt
= NULL
;
2020 struct symtab
*alt_symtab
= 0;
2022 /* Info on best line seen in this file. */
2024 struct linetable_entry
*prev
;
2026 /* If this pc is not from the current frame,
2027 it is the address of the end of a call instruction.
2028 Quite likely that is the start of the following statement.
2029 But what we want is the statement containing the instruction.
2030 Fudge the pc to make sure we get that. */
2032 init_sal (&val
); /* initialize to zeroes */
2034 /* It's tempting to assume that, if we can't find debugging info for
2035 any function enclosing PC, that we shouldn't search for line
2036 number info, either. However, GAS can emit line number info for
2037 assembly files --- very helpful when debugging hand-written
2038 assembly code. In such a case, we'd have no debug info for the
2039 function, but we would have line info. */
2044 /* elz: added this because this function returned the wrong
2045 information if the pc belongs to a stub (import/export)
2046 to call a shlib function. This stub would be anywhere between
2047 two functions in the target, and the line info was erroneously
2048 taken to be the one of the line before the pc.
2050 /* RT: Further explanation:
2052 * We have stubs (trampolines) inserted between procedures.
2054 * Example: "shr1" exists in a shared library, and a "shr1" stub also
2055 * exists in the main image.
2057 * In the minimal symbol table, we have a bunch of symbols
2058 * sorted by start address. The stubs are marked as "trampoline",
2059 * the others appear as text. E.g.:
2061 * Minimal symbol table for main image
2062 * main: code for main (text symbol)
2063 * shr1: stub (trampoline symbol)
2064 * foo: code for foo (text symbol)
2066 * Minimal symbol table for "shr1" image:
2068 * shr1: code for shr1 (text symbol)
2071 * So the code below is trying to detect if we are in the stub
2072 * ("shr1" stub), and if so, find the real code ("shr1" trampoline),
2073 * and if found, do the symbolization from the real-code address
2074 * rather than the stub address.
2076 * Assumptions being made about the minimal symbol table:
2077 * 1. lookup_minimal_symbol_by_pc() will return a trampoline only
2078 * if we're really in the trampoline. If we're beyond it (say
2079 * we're in "foo" in the above example), it'll have a closer
2080 * symbol (the "foo" text symbol for example) and will not
2081 * return the trampoline.
2082 * 2. lookup_minimal_symbol_text() will find a real text symbol
2083 * corresponding to the trampoline, and whose address will
2084 * be different than the trampoline address. I put in a sanity
2085 * check for the address being the same, to avoid an
2086 * infinite recursion.
2088 msymbol
= lookup_minimal_symbol_by_pc (pc
);
2089 if (msymbol
!= NULL
)
2090 if (MSYMBOL_TYPE (msymbol
) == mst_solib_trampoline
)
2092 mfunsym
= lookup_minimal_symbol_text (DEPRECATED_SYMBOL_NAME (msymbol
), NULL
, NULL
);
2093 if (mfunsym
== NULL
)
2094 /* I eliminated this warning since it is coming out
2095 * in the following situation:
2096 * gdb shmain // test program with shared libraries
2097 * (gdb) break shr1 // function in shared lib
2098 * Warning: In stub for ...
2099 * In the above situation, the shared lib is not loaded yet,
2100 * so of course we can't find the real func/line info,
2101 * but the "break" still works, and the warning is annoying.
2102 * So I commented out the warning. RT */
2103 /* warning ("In stub for %s; unable to find real function/line info", DEPRECATED_SYMBOL_NAME (msymbol)) */ ;
2105 else if (SYMBOL_VALUE (mfunsym
) == SYMBOL_VALUE (msymbol
))
2106 /* Avoid infinite recursion */
2107 /* See above comment about why warning is commented out */
2108 /* warning ("In stub for %s; unable to find real function/line info", DEPRECATED_SYMBOL_NAME (msymbol)) */ ;
2111 return find_pc_line (SYMBOL_VALUE (mfunsym
), 0);
2115 s
= find_pc_sect_symtab (pc
, section
);
2118 /* if no symbol information, return previous pc */
2125 bv
= BLOCKVECTOR (s
);
2127 /* Look at all the symtabs that share this blockvector.
2128 They all have the same apriori range, that we found was right;
2129 but they have different line tables. */
2131 for (; s
&& BLOCKVECTOR (s
) == bv
; s
= s
->next
)
2133 /* Find the best line in this symtab. */
2140 /* I think len can be zero if the symtab lacks line numbers
2141 (e.g. gcc -g1). (Either that or the LINETABLE is NULL;
2142 I'm not sure which, and maybe it depends on the symbol
2148 item
= l
->item
; /* Get first line info */
2150 /* Is this file's first line closer than the first lines of other files?
2151 If so, record this file, and its first line, as best alternate. */
2152 if (item
->pc
> pc
&& (!alt
|| item
->pc
< alt
->pc
))
2158 for (i
= 0; i
< len
; i
++, item
++)
2160 /* Leave prev pointing to the linetable entry for the last line
2161 that started at or before PC. */
2168 /* At this point, prev points at the line whose start addr is <= pc, and
2169 item points at the next line. If we ran off the end of the linetable
2170 (pc >= start of the last line), then prev == item. If pc < start of
2171 the first line, prev will not be set. */
2173 /* Is this file's best line closer than the best in the other files?
2174 If so, record this file, and its best line, as best so far. Don't
2175 save prev if it represents the end of a function (i.e. line number
2176 0) instead of a real line. */
2178 if (prev
&& prev
->line
&& (!best
|| prev
->pc
> best
->pc
))
2183 /* Discard BEST_END if it's before the PC of the current BEST. */
2184 if (best_end
<= best
->pc
)
2188 /* If another line (denoted by ITEM) is in the linetable and its
2189 PC is after BEST's PC, but before the current BEST_END, then
2190 use ITEM's PC as the new best_end. */
2191 if (best
&& i
< len
&& item
->pc
> best
->pc
2192 && (best_end
== 0 || best_end
> item
->pc
))
2193 best_end
= item
->pc
;
2199 { /* If we didn't find any line # info, just
2205 val
.symtab
= alt_symtab
;
2206 val
.line
= alt
->line
- 1;
2208 /* Don't return line 0, that means that we didn't find the line. */
2212 val
.pc
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
2216 else if (best
->line
== 0)
2218 /* If our best fit is in a range of PC's for which no line
2219 number info is available (line number is zero) then we didn't
2220 find any valid line information. */
2225 val
.symtab
= best_symtab
;
2226 val
.line
= best
->line
;
2228 if (best_end
&& (!alt
|| best_end
< alt
->pc
))
2233 val
.end
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
2235 val
.section
= section
;
2239 /* Backward compatibility (no section) */
2241 struct symtab_and_line
2242 find_pc_line (CORE_ADDR pc
, int notcurrent
)
2246 section
= find_pc_overlay (pc
);
2247 if (pc_in_unmapped_range (pc
, section
))
2248 pc
= overlay_mapped_address (pc
, section
);
2249 return find_pc_sect_line (pc
, section
, notcurrent
);
2252 /* Find line number LINE in any symtab whose name is the same as
2255 If found, return the symtab that contains the linetable in which it was
2256 found, set *INDEX to the index in the linetable of the best entry
2257 found, and set *EXACT_MATCH nonzero if the value returned is an
2260 If not found, return NULL. */
2263 find_line_symtab (struct symtab
*symtab
, int line
, int *index
, int *exact_match
)
2267 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
2271 struct linetable
*best_linetable
;
2272 struct symtab
*best_symtab
;
2274 /* First try looking it up in the given symtab. */
2275 best_linetable
= LINETABLE (symtab
);
2276 best_symtab
= symtab
;
2277 best_index
= find_line_common (best_linetable
, line
, &exact
);
2278 if (best_index
< 0 || !exact
)
2280 /* Didn't find an exact match. So we better keep looking for
2281 another symtab with the same name. In the case of xcoff,
2282 multiple csects for one source file (produced by IBM's FORTRAN
2283 compiler) produce multiple symtabs (this is unavoidable
2284 assuming csects can be at arbitrary places in memory and that
2285 the GLOBAL_BLOCK of a symtab has a begin and end address). */
2287 /* BEST is the smallest linenumber > LINE so far seen,
2288 or 0 if none has been seen so far.
2289 BEST_INDEX and BEST_LINETABLE identify the item for it. */
2292 struct objfile
*objfile
;
2295 if (best_index
>= 0)
2296 best
= best_linetable
->item
[best_index
].line
;
2300 ALL_SYMTABS (objfile
, s
)
2302 struct linetable
*l
;
2305 if (!STREQ (symtab
->filename
, s
->filename
))
2308 ind
= find_line_common (l
, line
, &exact
);
2318 if (best
== 0 || l
->item
[ind
].line
< best
)
2320 best
= l
->item
[ind
].line
;
2333 *index
= best_index
;
2335 *exact_match
= exact
;
2340 /* Set the PC value for a given source file and line number and return true.
2341 Returns zero for invalid line number (and sets the PC to 0).
2342 The source file is specified with a struct symtab. */
2345 find_line_pc (struct symtab
*symtab
, int line
, CORE_ADDR
*pc
)
2347 struct linetable
*l
;
2354 symtab
= find_line_symtab (symtab
, line
, &ind
, NULL
);
2357 l
= LINETABLE (symtab
);
2358 *pc
= l
->item
[ind
].pc
;
2365 /* Find the range of pc values in a line.
2366 Store the starting pc of the line into *STARTPTR
2367 and the ending pc (start of next line) into *ENDPTR.
2368 Returns 1 to indicate success.
2369 Returns 0 if could not find the specified line. */
2372 find_line_pc_range (struct symtab_and_line sal
, CORE_ADDR
*startptr
,
2375 CORE_ADDR startaddr
;
2376 struct symtab_and_line found_sal
;
2379 if (startaddr
== 0 && !find_line_pc (sal
.symtab
, sal
.line
, &startaddr
))
2382 /* This whole function is based on address. For example, if line 10 has
2383 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
2384 "info line *0x123" should say the line goes from 0x100 to 0x200
2385 and "info line *0x355" should say the line goes from 0x300 to 0x400.
2386 This also insures that we never give a range like "starts at 0x134
2387 and ends at 0x12c". */
2389 found_sal
= find_pc_sect_line (startaddr
, sal
.section
, 0);
2390 if (found_sal
.line
!= sal
.line
)
2392 /* The specified line (sal) has zero bytes. */
2393 *startptr
= found_sal
.pc
;
2394 *endptr
= found_sal
.pc
;
2398 *startptr
= found_sal
.pc
;
2399 *endptr
= found_sal
.end
;
2404 /* Given a line table and a line number, return the index into the line
2405 table for the pc of the nearest line whose number is >= the specified one.
2406 Return -1 if none is found. The value is >= 0 if it is an index.
2408 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
2411 find_line_common (register struct linetable
*l
, register int lineno
,
2417 /* BEST is the smallest linenumber > LINENO so far seen,
2418 or 0 if none has been seen so far.
2419 BEST_INDEX identifies the item for it. */
2421 int best_index
= -1;
2430 for (i
= 0; i
< len
; i
++)
2432 register struct linetable_entry
*item
= &(l
->item
[i
]);
2434 if (item
->line
== lineno
)
2436 /* Return the first (lowest address) entry which matches. */
2441 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
2448 /* If we got here, we didn't get an exact match. */
2455 find_pc_line_pc_range (CORE_ADDR pc
, CORE_ADDR
*startptr
, CORE_ADDR
*endptr
)
2457 struct symtab_and_line sal
;
2458 sal
= find_pc_line (pc
, 0);
2461 return sal
.symtab
!= 0;
2464 /* Given a function symbol SYM, find the symtab and line for the start
2466 If the argument FUNFIRSTLINE is nonzero, we want the first line
2467 of real code inside the function. */
2469 struct symtab_and_line
2470 find_function_start_sal (struct symbol
*sym
, int funfirstline
)
2473 struct symtab_and_line sal
;
2475 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
2476 fixup_symbol_section (sym
, NULL
);
2478 { /* skip "first line" of function (which is actually its prologue) */
2479 asection
*section
= SYMBOL_BFD_SECTION (sym
);
2480 /* If function is in an unmapped overlay, use its unmapped LMA
2481 address, so that SKIP_PROLOGUE has something unique to work on */
2482 if (section_is_overlay (section
) &&
2483 !section_is_mapped (section
))
2484 pc
= overlay_unmapped_address (pc
, section
);
2486 pc
+= FUNCTION_START_OFFSET
;
2487 pc
= SKIP_PROLOGUE (pc
);
2489 /* For overlays, map pc back into its mapped VMA range */
2490 pc
= overlay_mapped_address (pc
, section
);
2492 sal
= find_pc_sect_line (pc
, SYMBOL_BFD_SECTION (sym
), 0);
2494 #ifdef PROLOGUE_FIRSTLINE_OVERLAP
2495 /* Convex: no need to suppress code on first line, if any */
2498 /* Check if SKIP_PROLOGUE left us in mid-line, and the next
2499 line is still part of the same function. */
2501 && BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) <= sal
.end
2502 && sal
.end
< BLOCK_END (SYMBOL_BLOCK_VALUE (sym
)))
2504 /* First pc of next line */
2506 /* Recalculate the line number (might not be N+1). */
2507 sal
= find_pc_sect_line (pc
, SYMBOL_BFD_SECTION (sym
), 0);
2515 /* If P is of the form "operator[ \t]+..." where `...' is
2516 some legitimate operator text, return a pointer to the
2517 beginning of the substring of the operator text.
2518 Otherwise, return "". */
2520 operator_chars (char *p
, char **end
)
2523 if (strncmp (p
, "operator", 8))
2527 /* Don't get faked out by `operator' being part of a longer
2529 if (isalpha (*p
) || *p
== '_' || *p
== '$' || *p
== '\0')
2532 /* Allow some whitespace between `operator' and the operator symbol. */
2533 while (*p
== ' ' || *p
== '\t')
2536 /* Recognize 'operator TYPENAME'. */
2538 if (isalpha (*p
) || *p
== '_' || *p
== '$')
2540 register char *q
= p
+ 1;
2541 while (isalnum (*q
) || *q
== '_' || *q
== '$')
2550 case '\\': /* regexp quoting */
2553 if (p
[2] == '=') /* 'operator\*=' */
2555 else /* 'operator\*' */
2559 else if (p
[1] == '[')
2562 error ("mismatched quoting on brackets, try 'operator\\[\\]'");
2563 else if (p
[2] == '\\' && p
[3] == ']')
2565 *end
= p
+ 4; /* 'operator\[\]' */
2569 error ("nothing is allowed between '[' and ']'");
2573 /* Gratuitous qoute: skip it and move on. */
2595 if (p
[0] == '-' && p
[1] == '>')
2597 /* Struct pointer member operator 'operator->'. */
2600 *end
= p
+ 3; /* 'operator->*' */
2603 else if (p
[2] == '\\')
2605 *end
= p
+ 4; /* Hopefully 'operator->\*' */
2610 *end
= p
+ 2; /* 'operator->' */
2614 if (p
[1] == '=' || p
[1] == p
[0])
2625 error ("`operator ()' must be specified without whitespace in `()'");
2630 error ("`operator ?:' must be specified without whitespace in `?:'");
2635 error ("`operator []' must be specified without whitespace in `[]'");
2639 error ("`operator %s' not supported", p
);
2648 /* If FILE is not already in the table of files, return zero;
2649 otherwise return non-zero. Optionally add FILE to the table if ADD
2650 is non-zero. If *FIRST is non-zero, forget the old table
2653 filename_seen (const char *file
, int add
, int *first
)
2655 /* Table of files seen so far. */
2656 static const char **tab
= NULL
;
2657 /* Allocated size of tab in elements.
2658 Start with one 256-byte block (when using GNU malloc.c).
2659 24 is the malloc overhead when range checking is in effect. */
2660 static int tab_alloc_size
= (256 - 24) / sizeof (char *);
2661 /* Current size of tab in elements. */
2662 static int tab_cur_size
;
2668 tab
= (const char **) xmalloc (tab_alloc_size
* sizeof (*tab
));
2672 /* Is FILE in tab? */
2673 for (p
= tab
; p
< tab
+ tab_cur_size
; p
++)
2674 if (strcmp (*p
, file
) == 0)
2677 /* No; maybe add it to tab. */
2680 if (tab_cur_size
== tab_alloc_size
)
2682 tab_alloc_size
*= 2;
2683 tab
= (const char **) xrealloc ((char *) tab
,
2684 tab_alloc_size
* sizeof (*tab
));
2686 tab
[tab_cur_size
++] = file
;
2692 /* Slave routine for sources_info. Force line breaks at ,'s.
2693 NAME is the name to print and *FIRST is nonzero if this is the first
2694 name printed. Set *FIRST to zero. */
2696 output_source_filename (char *name
, int *first
)
2698 /* Since a single source file can result in several partial symbol
2699 tables, we need to avoid printing it more than once. Note: if
2700 some of the psymtabs are read in and some are not, it gets
2701 printed both under "Source files for which symbols have been
2702 read" and "Source files for which symbols will be read in on
2703 demand". I consider this a reasonable way to deal with the
2704 situation. I'm not sure whether this can also happen for
2705 symtabs; it doesn't hurt to check. */
2707 /* Was NAME already seen? */
2708 if (filename_seen (name
, 1, first
))
2710 /* Yes; don't print it again. */
2713 /* No; print it and reset *FIRST. */
2720 printf_filtered (", ");
2724 fputs_filtered (name
, gdb_stdout
);
2728 sources_info (char *ignore
, int from_tty
)
2730 register struct symtab
*s
;
2731 register struct partial_symtab
*ps
;
2732 register struct objfile
*objfile
;
2735 if (!have_full_symbols () && !have_partial_symbols ())
2737 error ("No symbol table is loaded. Use the \"file\" command.");
2740 printf_filtered ("Source files for which symbols have been read in:\n\n");
2743 ALL_SYMTABS (objfile
, s
)
2745 output_source_filename (s
->filename
, &first
);
2747 printf_filtered ("\n\n");
2749 printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
2752 ALL_PSYMTABS (objfile
, ps
)
2756 output_source_filename (ps
->filename
, &first
);
2759 printf_filtered ("\n");
2763 file_matches (char *file
, char *files
[], int nfiles
)
2767 if (file
!= NULL
&& nfiles
!= 0)
2769 for (i
= 0; i
< nfiles
; i
++)
2771 if (strcmp (files
[i
], lbasename (file
)) == 0)
2775 else if (nfiles
== 0)
2780 /* Free any memory associated with a search. */
2782 free_search_symbols (struct symbol_search
*symbols
)
2784 struct symbol_search
*p
;
2785 struct symbol_search
*next
;
2787 for (p
= symbols
; p
!= NULL
; p
= next
)
2795 do_free_search_symbols_cleanup (void *symbols
)
2797 free_search_symbols (symbols
);
2801 make_cleanup_free_search_symbols (struct symbol_search
*symbols
)
2803 return make_cleanup (do_free_search_symbols_cleanup
, symbols
);
2806 /* Helper function for sort_search_symbols and qsort. Can only
2807 sort symbols, not minimal symbols. */
2809 compare_search_syms (const void *sa
, const void *sb
)
2811 struct symbol_search
**sym_a
= (struct symbol_search
**) sa
;
2812 struct symbol_search
**sym_b
= (struct symbol_search
**) sb
;
2814 return strcmp (SYMBOL_PRINT_NAME ((*sym_a
)->symbol
),
2815 SYMBOL_PRINT_NAME ((*sym_b
)->symbol
));
2818 /* Sort the ``nfound'' symbols in the list after prevtail. Leave
2819 prevtail where it is, but update its next pointer to point to
2820 the first of the sorted symbols. */
2821 static struct symbol_search
*
2822 sort_search_symbols (struct symbol_search
*prevtail
, int nfound
)
2824 struct symbol_search
**symbols
, *symp
, *old_next
;
2827 symbols
= (struct symbol_search
**) xmalloc (sizeof (struct symbol_search
*)
2829 symp
= prevtail
->next
;
2830 for (i
= 0; i
< nfound
; i
++)
2835 /* Generally NULL. */
2838 qsort (symbols
, nfound
, sizeof (struct symbol_search
*),
2839 compare_search_syms
);
2842 for (i
= 0; i
< nfound
; i
++)
2844 symp
->next
= symbols
[i
];
2847 symp
->next
= old_next
;
2853 /* Search the symbol table for matches to the regular expression REGEXP,
2854 returning the results in *MATCHES.
2856 Only symbols of KIND are searched:
2857 FUNCTIONS_NAMESPACE - search all functions
2858 TYPES_NAMESPACE - search all type names
2859 METHODS_NAMESPACE - search all methods NOT IMPLEMENTED
2860 VARIABLES_NAMESPACE - search all symbols, excluding functions, type names,
2861 and constants (enums)
2863 free_search_symbols should be called when *MATCHES is no longer needed.
2865 The results are sorted locally; each symtab's global and static blocks are
2866 separately alphabetized.
2869 search_symbols (char *regexp
, namespace_enum kind
, int nfiles
, char *files
[],
2870 struct symbol_search
**matches
)
2872 register struct symtab
*s
;
2873 register struct partial_symtab
*ps
;
2874 register struct blockvector
*bv
;
2875 struct blockvector
*prev_bv
= 0;
2876 register struct block
*b
;
2879 register struct symbol
*sym
;
2880 struct partial_symbol
**psym
;
2881 struct objfile
*objfile
;
2882 struct minimal_symbol
*msymbol
;
2885 static enum minimal_symbol_type types
[]
2887 {mst_data
, mst_text
, mst_abs
, mst_unknown
};
2888 static enum minimal_symbol_type types2
[]
2890 {mst_bss
, mst_file_text
, mst_abs
, mst_unknown
};
2891 static enum minimal_symbol_type types3
[]
2893 {mst_file_data
, mst_solib_trampoline
, mst_abs
, mst_unknown
};
2894 static enum minimal_symbol_type types4
[]
2896 {mst_file_bss
, mst_text
, mst_abs
, mst_unknown
};
2897 enum minimal_symbol_type ourtype
;
2898 enum minimal_symbol_type ourtype2
;
2899 enum minimal_symbol_type ourtype3
;
2900 enum minimal_symbol_type ourtype4
;
2901 struct symbol_search
*sr
;
2902 struct symbol_search
*psr
;
2903 struct symbol_search
*tail
;
2904 struct cleanup
*old_chain
= NULL
;
2906 if (kind
< VARIABLES_NAMESPACE
)
2907 error ("must search on specific namespace");
2909 ourtype
= types
[(int) (kind
- VARIABLES_NAMESPACE
)];
2910 ourtype2
= types2
[(int) (kind
- VARIABLES_NAMESPACE
)];
2911 ourtype3
= types3
[(int) (kind
- VARIABLES_NAMESPACE
)];
2912 ourtype4
= types4
[(int) (kind
- VARIABLES_NAMESPACE
)];
2914 sr
= *matches
= NULL
;
2919 /* Make sure spacing is right for C++ operators.
2920 This is just a courtesy to make the matching less sensitive
2921 to how many spaces the user leaves between 'operator'
2922 and <TYPENAME> or <OPERATOR>. */
2924 char *opname
= operator_chars (regexp
, &opend
);
2927 int fix
= -1; /* -1 means ok; otherwise number of spaces needed. */
2928 if (isalpha (*opname
) || *opname
== '_' || *opname
== '$')
2930 /* There should 1 space between 'operator' and 'TYPENAME'. */
2931 if (opname
[-1] != ' ' || opname
[-2] == ' ')
2936 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
2937 if (opname
[-1] == ' ')
2940 /* If wrong number of spaces, fix it. */
2943 char *tmp
= (char *) alloca (8 + fix
+ strlen (opname
) + 1);
2944 sprintf (tmp
, "operator%.*s%s", fix
, " ", opname
);
2949 if (0 != (val
= re_comp (regexp
)))
2950 error ("Invalid regexp (%s): %s", val
, regexp
);
2953 /* Search through the partial symtabs *first* for all symbols
2954 matching the regexp. That way we don't have to reproduce all of
2955 the machinery below. */
2957 ALL_PSYMTABS (objfile
, ps
)
2959 struct partial_symbol
**bound
, **gbound
, **sbound
;
2965 gbound
= objfile
->global_psymbols
.list
+ ps
->globals_offset
+ ps
->n_global_syms
;
2966 sbound
= objfile
->static_psymbols
.list
+ ps
->statics_offset
+ ps
->n_static_syms
;
2969 /* Go through all of the symbols stored in a partial
2970 symtab in one loop. */
2971 psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2976 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
2978 psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
2989 /* If it would match (logic taken from loop below)
2990 load the file and go on to the next one */
2991 if (file_matches (ps
->filename
, files
, nfiles
)
2993 || re_exec (SYMBOL_NATURAL_NAME (*psym
)) != 0)
2994 && ((kind
== VARIABLES_NAMESPACE
&& SYMBOL_CLASS (*psym
) != LOC_TYPEDEF
2995 && SYMBOL_CLASS (*psym
) != LOC_BLOCK
)
2996 || (kind
== FUNCTIONS_NAMESPACE
&& SYMBOL_CLASS (*psym
) == LOC_BLOCK
)
2997 || (kind
== TYPES_NAMESPACE
&& SYMBOL_CLASS (*psym
) == LOC_TYPEDEF
)
2998 || (kind
== METHODS_NAMESPACE
&& SYMBOL_CLASS (*psym
) == LOC_BLOCK
))))
3000 PSYMTAB_TO_SYMTAB (ps
);
3008 /* Here, we search through the minimal symbol tables for functions
3009 and variables that match, and force their symbols to be read.
3010 This is in particular necessary for demangled variable names,
3011 which are no longer put into the partial symbol tables.
3012 The symbol will then be found during the scan of symtabs below.
3014 For functions, find_pc_symtab should succeed if we have debug info
3015 for the function, for variables we have to call lookup_symbol
3016 to determine if the variable has debug info.
3017 If the lookup fails, set found_misc so that we will rescan to print
3018 any matching symbols without debug info.
3021 if (nfiles
== 0 && (kind
== VARIABLES_NAMESPACE
|| kind
== FUNCTIONS_NAMESPACE
))
3023 ALL_MSYMBOLS (objfile
, msymbol
)
3025 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
3026 MSYMBOL_TYPE (msymbol
) == ourtype2
||
3027 MSYMBOL_TYPE (msymbol
) == ourtype3
||
3028 MSYMBOL_TYPE (msymbol
) == ourtype4
)
3031 || re_exec (SYMBOL_NATURAL_NAME (msymbol
)) != 0)
3033 if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
)))
3035 /* FIXME: carlton/2003-02-04: Given that the
3036 semantics of lookup_symbol keeps on changing
3037 slightly, it would be a nice idea if we had a
3038 function lookup_symbol_minsym that found the
3039 symbol associated to a given minimal symbol (if
3041 if (kind
== FUNCTIONS_NAMESPACE
3042 || lookup_symbol (DEPRECATED_SYMBOL_NAME (msymbol
),
3043 (struct block
*) NULL
,
3045 0, (struct symtab
**) NULL
) == NULL
)
3053 ALL_SYMTABS (objfile
, s
)
3055 bv
= BLOCKVECTOR (s
);
3056 /* Often many files share a blockvector.
3057 Scan each blockvector only once so that
3058 we don't get every symbol many times.
3059 It happens that the first symtab in the list
3060 for any given blockvector is the main file. */
3062 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
3064 struct symbol_search
*prevtail
= tail
;
3066 b
= BLOCKVECTOR_BLOCK (bv
, i
);
3067 ALL_BLOCK_SYMBOLS (b
, j
, sym
)
3070 if (file_matches (s
->filename
, files
, nfiles
)
3072 || re_exec (SYMBOL_NATURAL_NAME (sym
)) != 0)
3073 && ((kind
== VARIABLES_NAMESPACE
&& SYMBOL_CLASS (sym
) != LOC_TYPEDEF
3074 && SYMBOL_CLASS (sym
) != LOC_BLOCK
3075 && SYMBOL_CLASS (sym
) != LOC_CONST
)
3076 || (kind
== FUNCTIONS_NAMESPACE
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
3077 || (kind
== TYPES_NAMESPACE
&& SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
3078 || (kind
== METHODS_NAMESPACE
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
))))
3081 psr
= (struct symbol_search
*) xmalloc (sizeof (struct symbol_search
));
3085 psr
->msymbol
= NULL
;
3097 if (prevtail
== NULL
)
3099 struct symbol_search dummy
;
3102 tail
= sort_search_symbols (&dummy
, nfound
);
3105 old_chain
= make_cleanup_free_search_symbols (sr
);
3108 tail
= sort_search_symbols (prevtail
, nfound
);
3114 /* If there are no eyes, avoid all contact. I mean, if there are
3115 no debug symbols, then print directly from the msymbol_vector. */
3117 if (found_misc
|| kind
!= FUNCTIONS_NAMESPACE
)
3119 ALL_MSYMBOLS (objfile
, msymbol
)
3121 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
3122 MSYMBOL_TYPE (msymbol
) == ourtype2
||
3123 MSYMBOL_TYPE (msymbol
) == ourtype3
||
3124 MSYMBOL_TYPE (msymbol
) == ourtype4
)
3127 || re_exec (SYMBOL_NATURAL_NAME (msymbol
)) != 0)
3129 /* Functions: Look up by address. */
3130 if (kind
!= FUNCTIONS_NAMESPACE
||
3131 (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
))))
3133 /* Variables/Absolutes: Look up by name */
3134 if (lookup_symbol (DEPRECATED_SYMBOL_NAME (msymbol
),
3135 (struct block
*) NULL
, VAR_NAMESPACE
,
3136 0, (struct symtab
**) NULL
) == NULL
)
3139 psr
= (struct symbol_search
*) xmalloc (sizeof (struct symbol_search
));
3141 psr
->msymbol
= msymbol
;
3148 old_chain
= make_cleanup_free_search_symbols (sr
);
3162 discard_cleanups (old_chain
);
3165 /* Helper function for symtab_symbol_info, this function uses
3166 the data returned from search_symbols() to print information
3167 regarding the match to gdb_stdout.
3170 print_symbol_info (namespace_enum kind
, struct symtab
*s
, struct symbol
*sym
,
3171 int block
, char *last
)
3173 if (last
== NULL
|| strcmp (last
, s
->filename
) != 0)
3175 fputs_filtered ("\nFile ", gdb_stdout
);
3176 fputs_filtered (s
->filename
, gdb_stdout
);
3177 fputs_filtered (":\n", gdb_stdout
);
3180 if (kind
!= TYPES_NAMESPACE
&& block
== STATIC_BLOCK
)
3181 printf_filtered ("static ");
3183 /* Typedef that is not a C++ class */
3184 if (kind
== TYPES_NAMESPACE
3185 && SYMBOL_NAMESPACE (sym
) != STRUCT_NAMESPACE
)
3186 typedef_print (SYMBOL_TYPE (sym
), sym
, gdb_stdout
);
3187 /* variable, func, or typedef-that-is-c++-class */
3188 else if (kind
< TYPES_NAMESPACE
||
3189 (kind
== TYPES_NAMESPACE
&&
3190 SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
))
3192 type_print (SYMBOL_TYPE (sym
),
3193 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
3194 ? "" : SYMBOL_PRINT_NAME (sym
)),
3197 printf_filtered (";\n");
3201 /* This help function for symtab_symbol_info() prints information
3202 for non-debugging symbols to gdb_stdout.
3205 print_msymbol_info (struct minimal_symbol
*msymbol
)
3209 if (TARGET_ADDR_BIT
<= 32)
3210 tmp
= local_hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol
)
3211 & (CORE_ADDR
) 0xffffffff,
3214 tmp
= local_hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol
),
3216 printf_filtered ("%s %s\n",
3217 tmp
, SYMBOL_PRINT_NAME (msymbol
));
3220 /* This is the guts of the commands "info functions", "info types", and
3221 "info variables". It calls search_symbols to find all matches and then
3222 print_[m]symbol_info to print out some useful information about the
3226 symtab_symbol_info (char *regexp
, namespace_enum kind
, int from_tty
)
3228 static char *classnames
[]
3230 {"variable", "function", "type", "method"};
3231 struct symbol_search
*symbols
;
3232 struct symbol_search
*p
;
3233 struct cleanup
*old_chain
;
3234 char *last_filename
= NULL
;
3237 /* must make sure that if we're interrupted, symbols gets freed */
3238 search_symbols (regexp
, kind
, 0, (char **) NULL
, &symbols
);
3239 old_chain
= make_cleanup_free_search_symbols (symbols
);
3241 printf_filtered (regexp
3242 ? "All %ss matching regular expression \"%s\":\n"
3243 : "All defined %ss:\n",
3244 classnames
[(int) (kind
- VARIABLES_NAMESPACE
)], regexp
);
3246 for (p
= symbols
; p
!= NULL
; p
= p
->next
)
3250 if (p
->msymbol
!= NULL
)
3254 printf_filtered ("\nNon-debugging symbols:\n");
3257 print_msymbol_info (p
->msymbol
);
3261 print_symbol_info (kind
,
3266 last_filename
= p
->symtab
->filename
;
3270 do_cleanups (old_chain
);
3274 variables_info (char *regexp
, int from_tty
)
3276 symtab_symbol_info (regexp
, VARIABLES_NAMESPACE
, from_tty
);
3280 functions_info (char *regexp
, int from_tty
)
3282 symtab_symbol_info (regexp
, FUNCTIONS_NAMESPACE
, from_tty
);
3287 types_info (char *regexp
, int from_tty
)
3289 symtab_symbol_info (regexp
, TYPES_NAMESPACE
, from_tty
);
3292 /* Breakpoint all functions matching regular expression. */
3295 rbreak_command_wrapper (char *regexp
, int from_tty
)
3297 rbreak_command (regexp
, from_tty
);
3301 rbreak_command (char *regexp
, int from_tty
)
3303 struct symbol_search
*ss
;
3304 struct symbol_search
*p
;
3305 struct cleanup
*old_chain
;
3307 search_symbols (regexp
, FUNCTIONS_NAMESPACE
, 0, (char **) NULL
, &ss
);
3308 old_chain
= make_cleanup_free_search_symbols (ss
);
3310 for (p
= ss
; p
!= NULL
; p
= p
->next
)
3312 if (p
->msymbol
== NULL
)
3314 char *string
= (char *) alloca (strlen (p
->symtab
->filename
)
3315 + strlen (DEPRECATED_SYMBOL_NAME (p
->symbol
))
3317 strcpy (string
, p
->symtab
->filename
);
3318 strcat (string
, ":'");
3319 strcat (string
, DEPRECATED_SYMBOL_NAME (p
->symbol
));
3320 strcat (string
, "'");
3321 break_command (string
, from_tty
);
3322 print_symbol_info (FUNCTIONS_NAMESPACE
,
3326 p
->symtab
->filename
);
3330 break_command (DEPRECATED_SYMBOL_NAME (p
->msymbol
), from_tty
);
3331 printf_filtered ("<function, no debug info> %s;\n",
3332 SYMBOL_PRINT_NAME (p
->msymbol
));
3336 do_cleanups (old_chain
);
3340 /* Helper routine for make_symbol_completion_list. */
3342 static int return_val_size
;
3343 static int return_val_index
;
3344 static char **return_val
;
3346 #define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
3348 if (SYMBOL_DEMANGLED_NAME (symbol) != NULL) \
3349 /* Put only the mangled name on the list. */ \
3350 /* Advantage: "b foo<TAB>" completes to "b foo(int, int)" */ \
3351 /* Disadvantage: "b foo__i<TAB>" doesn't complete. */ \
3352 completion_list_add_name \
3353 (SYMBOL_DEMANGLED_NAME (symbol), (sym_text), (len), (text), (word)); \
3355 completion_list_add_name \
3356 (DEPRECATED_SYMBOL_NAME (symbol), (sym_text), (len), (text), (word)); \
3359 /* Test to see if the symbol specified by SYMNAME (which is already
3360 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
3361 characters. If so, add it to the current completion list. */
3364 completion_list_add_name (char *symname
, char *sym_text
, int sym_text_len
,
3365 char *text
, char *word
)
3370 /* clip symbols that cannot match */
3372 if (strncmp (symname
, sym_text
, sym_text_len
) != 0)
3377 /* We have a match for a completion, so add SYMNAME to the current list
3378 of matches. Note that the name is moved to freshly malloc'd space. */
3382 if (word
== sym_text
)
3384 new = xmalloc (strlen (symname
) + 5);
3385 strcpy (new, symname
);
3387 else if (word
> sym_text
)
3389 /* Return some portion of symname. */
3390 new = xmalloc (strlen (symname
) + 5);
3391 strcpy (new, symname
+ (word
- sym_text
));
3395 /* Return some of SYM_TEXT plus symname. */
3396 new = xmalloc (strlen (symname
) + (sym_text
- word
) + 5);
3397 strncpy (new, word
, sym_text
- word
);
3398 new[sym_text
- word
] = '\0';
3399 strcat (new, symname
);
3402 if (return_val_index
+ 3 > return_val_size
)
3404 newsize
= (return_val_size
*= 2) * sizeof (char *);
3405 return_val
= (char **) xrealloc ((char *) return_val
, newsize
);
3407 return_val
[return_val_index
++] = new;
3408 return_val
[return_val_index
] = NULL
;
3412 /* Return a NULL terminated array of all symbols (regardless of class)
3413 which begin by matching TEXT. If the answer is no symbols, then
3414 the return value is an array which contains only a NULL pointer.
3416 Problem: All of the symbols have to be copied because readline frees them.
3417 I'm not going to worry about this; hopefully there won't be that many. */
3420 make_symbol_completion_list (char *text
, char *word
)
3422 register struct symbol
*sym
;
3423 register struct symtab
*s
;
3424 register struct partial_symtab
*ps
;
3425 register struct minimal_symbol
*msymbol
;
3426 register struct objfile
*objfile
;
3427 register struct block
*b
, *surrounding_static_block
= 0;
3429 struct partial_symbol
**psym
;
3430 /* The symbol we are completing on. Points in same buffer as text. */
3432 /* Length of sym_text. */
3435 /* Now look for the symbol we are supposed to complete on.
3436 FIXME: This should be language-specific. */
3440 char *quote_pos
= NULL
;
3442 /* First see if this is a quoted string. */
3444 for (p
= text
; *p
!= '\0'; ++p
)
3446 if (quote_found
!= '\0')
3448 if (*p
== quote_found
)
3449 /* Found close quote. */
3451 else if (*p
== '\\' && p
[1] == quote_found
)
3452 /* A backslash followed by the quote character
3453 doesn't end the string. */
3456 else if (*p
== '\'' || *p
== '"')
3462 if (quote_found
== '\'')
3463 /* A string within single quotes can be a symbol, so complete on it. */
3464 sym_text
= quote_pos
+ 1;
3465 else if (quote_found
== '"')
3466 /* A double-quoted string is never a symbol, nor does it make sense
3467 to complete it any other way. */
3469 return_val
= (char **) xmalloc (sizeof (char *));
3470 return_val
[0] = NULL
;
3475 /* It is not a quoted string. Break it based on the characters
3476 which are in symbols. */
3479 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
3488 sym_text_len
= strlen (sym_text
);
3490 return_val_size
= 100;
3491 return_val_index
= 0;
3492 return_val
= (char **) xmalloc ((return_val_size
+ 1) * sizeof (char *));
3493 return_val
[0] = NULL
;
3495 /* Look through the partial symtabs for all symbols which begin
3496 by matching SYM_TEXT. Add each one that you find to the list. */
3498 ALL_PSYMTABS (objfile
, ps
)
3500 /* If the psymtab's been read in we'll get it when we search
3501 through the blockvector. */
3505 for (psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
3506 psym
< (objfile
->global_psymbols
.list
+ ps
->globals_offset
3507 + ps
->n_global_syms
);
3510 /* If interrupted, then quit. */
3512 COMPLETION_LIST_ADD_SYMBOL (*psym
, sym_text
, sym_text_len
, text
, word
);
3515 for (psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
3516 psym
< (objfile
->static_psymbols
.list
+ ps
->statics_offset
3517 + ps
->n_static_syms
);
3521 COMPLETION_LIST_ADD_SYMBOL (*psym
, sym_text
, sym_text_len
, text
, word
);
3525 /* At this point scan through the misc symbol vectors and add each
3526 symbol you find to the list. Eventually we want to ignore
3527 anything that isn't a text symbol (everything else will be
3528 handled by the psymtab code above). */
3530 ALL_MSYMBOLS (objfile
, msymbol
)
3533 COMPLETION_LIST_ADD_SYMBOL (msymbol
, sym_text
, sym_text_len
, text
, word
);
3536 /* Search upwards from currently selected frame (so that we can
3537 complete on local vars. */
3539 for (b
= get_selected_block (0); b
!= NULL
; b
= BLOCK_SUPERBLOCK (b
))
3541 if (!BLOCK_SUPERBLOCK (b
))
3543 surrounding_static_block
= b
; /* For elmin of dups */
3546 /* Also catch fields of types defined in this places which match our
3547 text string. Only complete on types visible from current context. */
3549 ALL_BLOCK_SYMBOLS (b
, i
, sym
)
3551 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3552 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
3554 struct type
*t
= SYMBOL_TYPE (sym
);
3555 enum type_code c
= TYPE_CODE (t
);
3557 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
3559 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
3561 if (TYPE_FIELD_NAME (t
, j
))
3563 completion_list_add_name (TYPE_FIELD_NAME (t
, j
),
3564 sym_text
, sym_text_len
, text
, word
);
3572 /* Go through the symtabs and check the externs and statics for
3573 symbols which match. */
3575 ALL_SYMTABS (objfile
, s
)
3578 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
3579 ALL_BLOCK_SYMBOLS (b
, i
, sym
)
3581 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3585 ALL_SYMTABS (objfile
, s
)
3588 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
3589 /* Don't do this block twice. */
3590 if (b
== surrounding_static_block
)
3592 ALL_BLOCK_SYMBOLS (b
, i
, sym
)
3594 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3598 return (return_val
);
3601 /* Like make_symbol_completion_list, but returns a list of symbols
3602 defined in a source file FILE. */
3605 make_file_symbol_completion_list (char *text
, char *word
, char *srcfile
)
3607 register struct symbol
*sym
;
3608 register struct symtab
*s
;
3609 register struct block
*b
;
3611 /* The symbol we are completing on. Points in same buffer as text. */
3613 /* Length of sym_text. */
3616 /* Now look for the symbol we are supposed to complete on.
3617 FIXME: This should be language-specific. */
3621 char *quote_pos
= NULL
;
3623 /* First see if this is a quoted string. */
3625 for (p
= text
; *p
!= '\0'; ++p
)
3627 if (quote_found
!= '\0')
3629 if (*p
== quote_found
)
3630 /* Found close quote. */
3632 else if (*p
== '\\' && p
[1] == quote_found
)
3633 /* A backslash followed by the quote character
3634 doesn't end the string. */
3637 else if (*p
== '\'' || *p
== '"')
3643 if (quote_found
== '\'')
3644 /* A string within single quotes can be a symbol, so complete on it. */
3645 sym_text
= quote_pos
+ 1;
3646 else if (quote_found
== '"')
3647 /* A double-quoted string is never a symbol, nor does it make sense
3648 to complete it any other way. */
3650 return_val
= (char **) xmalloc (sizeof (char *));
3651 return_val
[0] = NULL
;
3656 /* It is not a quoted string. Break it based on the characters
3657 which are in symbols. */
3660 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
3669 sym_text_len
= strlen (sym_text
);
3671 return_val_size
= 10;
3672 return_val_index
= 0;
3673 return_val
= (char **) xmalloc ((return_val_size
+ 1) * sizeof (char *));
3674 return_val
[0] = NULL
;
3676 /* Find the symtab for SRCFILE (this loads it if it was not yet read
3678 s
= lookup_symtab (srcfile
);
3681 /* Maybe they typed the file with leading directories, while the
3682 symbol tables record only its basename. */
3683 const char *tail
= lbasename (srcfile
);
3686 s
= lookup_symtab (tail
);
3689 /* If we have no symtab for that file, return an empty list. */
3691 return (return_val
);
3693 /* Go through this symtab and check the externs and statics for
3694 symbols which match. */
3696 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
3697 ALL_BLOCK_SYMBOLS (b
, i
, sym
)
3699 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3702 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
3703 ALL_BLOCK_SYMBOLS (b
, i
, sym
)
3705 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3708 return (return_val
);
3711 /* A helper function for make_source_files_completion_list. It adds
3712 another file name to a list of possible completions, growing the
3713 list as necessary. */
3716 add_filename_to_list (const char *fname
, char *text
, char *word
,
3717 char ***list
, int *list_used
, int *list_alloced
)
3720 size_t fnlen
= strlen (fname
);
3722 if (*list_used
+ 1 >= *list_alloced
)
3725 *list
= (char **) xrealloc ((char *) *list
,
3726 *list_alloced
* sizeof (char *));
3731 /* Return exactly fname. */
3732 new = xmalloc (fnlen
+ 5);
3733 strcpy (new, fname
);
3735 else if (word
> text
)
3737 /* Return some portion of fname. */
3738 new = xmalloc (fnlen
+ 5);
3739 strcpy (new, fname
+ (word
- text
));
3743 /* Return some of TEXT plus fname. */
3744 new = xmalloc (fnlen
+ (text
- word
) + 5);
3745 strncpy (new, word
, text
- word
);
3746 new[text
- word
] = '\0';
3747 strcat (new, fname
);
3749 (*list
)[*list_used
] = new;
3750 (*list
)[++*list_used
] = NULL
;
3754 not_interesting_fname (const char *fname
)
3756 static const char *illegal_aliens
[] = {
3757 "_globals_", /* inserted by coff_symtab_read */
3762 for (i
= 0; illegal_aliens
[i
]; i
++)
3764 if (strcmp (fname
, illegal_aliens
[i
]) == 0)
3770 /* Return a NULL terminated array of all source files whose names
3771 begin with matching TEXT. The file names are looked up in the
3772 symbol tables of this program. If the answer is no matchess, then
3773 the return value is an array which contains only a NULL pointer. */
3776 make_source_files_completion_list (char *text
, char *word
)
3778 register struct symtab
*s
;
3779 register struct partial_symtab
*ps
;
3780 register struct objfile
*objfile
;
3782 int list_alloced
= 1;
3784 size_t text_len
= strlen (text
);
3785 char **list
= (char **) xmalloc (list_alloced
* sizeof (char *));
3786 const char *base_name
;
3790 if (!have_full_symbols () && !have_partial_symbols ())
3793 ALL_SYMTABS (objfile
, s
)
3795 if (not_interesting_fname (s
->filename
))
3797 if (!filename_seen (s
->filename
, 1, &first
)
3798 #if HAVE_DOS_BASED_FILE_SYSTEM
3799 && strncasecmp (s
->filename
, text
, text_len
) == 0
3801 && strncmp (s
->filename
, text
, text_len
) == 0
3805 /* This file matches for a completion; add it to the current
3807 add_filename_to_list (s
->filename
, text
, word
,
3808 &list
, &list_used
, &list_alloced
);
3812 /* NOTE: We allow the user to type a base name when the
3813 debug info records leading directories, but not the other
3814 way around. This is what subroutines of breakpoint
3815 command do when they parse file names. */
3816 base_name
= lbasename (s
->filename
);
3817 if (base_name
!= s
->filename
3818 && !filename_seen (base_name
, 1, &first
)
3819 #if HAVE_DOS_BASED_FILE_SYSTEM
3820 && strncasecmp (base_name
, text
, text_len
) == 0
3822 && strncmp (base_name
, text
, text_len
) == 0
3825 add_filename_to_list (base_name
, text
, word
,
3826 &list
, &list_used
, &list_alloced
);
3830 ALL_PSYMTABS (objfile
, ps
)
3832 if (not_interesting_fname (ps
->filename
))
3836 if (!filename_seen (ps
->filename
, 1, &first
)
3837 #if HAVE_DOS_BASED_FILE_SYSTEM
3838 && strncasecmp (ps
->filename
, text
, text_len
) == 0
3840 && strncmp (ps
->filename
, text
, text_len
) == 0
3844 /* This file matches for a completion; add it to the
3845 current list of matches. */
3846 add_filename_to_list (ps
->filename
, text
, word
,
3847 &list
, &list_used
, &list_alloced
);
3852 base_name
= lbasename (ps
->filename
);
3853 if (base_name
!= ps
->filename
3854 && !filename_seen (base_name
, 1, &first
)
3855 #if HAVE_DOS_BASED_FILE_SYSTEM
3856 && strncasecmp (base_name
, text
, text_len
) == 0
3858 && strncmp (base_name
, text
, text_len
) == 0
3861 add_filename_to_list (base_name
, text
, word
,
3862 &list
, &list_used
, &list_alloced
);
3870 /* Determine if PC is in the prologue of a function. The prologue is the area
3871 between the first instruction of a function, and the first executable line.
3872 Returns 1 if PC *might* be in prologue, 0 if definately *not* in prologue.
3874 If non-zero, func_start is where we think the prologue starts, possibly
3875 by previous examination of symbol table information.
3879 in_prologue (CORE_ADDR pc
, CORE_ADDR func_start
)
3881 struct symtab_and_line sal
;
3882 CORE_ADDR func_addr
, func_end
;
3884 /* We have several sources of information we can consult to figure
3886 - Compilers usually emit line number info that marks the prologue
3887 as its own "source line". So the ending address of that "line"
3888 is the end of the prologue. If available, this is the most
3890 - The minimal symbols and partial symbols, which can usually tell
3891 us the starting and ending addresses of a function.
3892 - If we know the function's start address, we can call the
3893 architecture-defined SKIP_PROLOGUE function to analyze the
3894 instruction stream and guess where the prologue ends.
3895 - Our `func_start' argument; if non-zero, this is the caller's
3896 best guess as to the function's entry point. At the time of
3897 this writing, handle_inferior_event doesn't get this right, so
3898 it should be our last resort. */
3900 /* Consult the partial symbol table, to find which function
3902 if (! find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
3904 CORE_ADDR prologue_end
;
3906 /* We don't even have minsym information, so fall back to using
3907 func_start, if given. */
3909 return 1; /* We *might* be in a prologue. */
3911 prologue_end
= SKIP_PROLOGUE (func_start
);
3913 return func_start
<= pc
&& pc
< prologue_end
;
3916 /* If we have line number information for the function, that's
3917 usually pretty reliable. */
3918 sal
= find_pc_line (func_addr
, 0);
3920 /* Now sal describes the source line at the function's entry point,
3921 which (by convention) is the prologue. The end of that "line",
3922 sal.end, is the end of the prologue.
3924 Note that, for functions whose source code is all on a single
3925 line, the line number information doesn't always end up this way.
3926 So we must verify that our purported end-of-prologue address is
3927 *within* the function, not at its start or end. */
3929 || sal
.end
<= func_addr
3930 || func_end
<= sal
.end
)
3932 /* We don't have any good line number info, so use the minsym
3933 information, together with the architecture-specific prologue
3935 CORE_ADDR prologue_end
= SKIP_PROLOGUE (func_addr
);
3937 return func_addr
<= pc
&& pc
< prologue_end
;
3940 /* We have line number info, and it looks good. */
3941 return func_addr
<= pc
&& pc
< sal
.end
;
3945 /* Begin overload resolution functions */
3948 remove_params (const char *demangled_name
)
3954 if (demangled_name
== NULL
)
3957 /* First find the end of the arg list. */
3958 argp
= strrchr (demangled_name
, ')');
3962 /* Back up to the beginning. */
3965 while (argp
-- > demangled_name
)
3969 else if (*argp
== '(')
3978 internal_error (__FILE__
, __LINE__
,
3979 "bad demangled name %s\n", demangled_name
);
3980 while (argp
[-1] == ' ' && argp
> demangled_name
)
3983 new_name
= xmalloc (argp
- demangled_name
+ 1);
3984 memcpy (new_name
, demangled_name
, argp
- demangled_name
);
3985 new_name
[argp
- demangled_name
] = '\0';
3989 /* Helper routine for make_symbol_completion_list. */
3991 static int sym_return_val_size
;
3992 static int sym_return_val_index
;
3993 static struct symbol
**sym_return_val
;
3995 /* Test to see if the symbol specified by SYMNAME (which is already
3996 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
3997 characters. If so, add it to the current completion list. */
4000 overload_list_add_symbol (struct symbol
*sym
, char *oload_name
)
4006 /* If there is no type information, we can't do anything, so skip */
4007 if (SYMBOL_TYPE (sym
) == NULL
)
4010 /* skip any symbols that we've already considered. */
4011 for (i
= 0; i
< sym_return_val_index
; ++i
)
4012 if (!strcmp (DEPRECATED_SYMBOL_NAME (sym
), DEPRECATED_SYMBOL_NAME (sym_return_val
[i
])))
4015 /* Get the demangled name without parameters */
4016 sym_name
= remove_params (SYMBOL_DEMANGLED_NAME (sym
));
4020 /* skip symbols that cannot match */
4021 if (strcmp (sym_name
, oload_name
) != 0)
4029 /* We have a match for an overload instance, so add SYM to the current list
4030 * of overload instances */
4031 if (sym_return_val_index
+ 3 > sym_return_val_size
)
4033 newsize
= (sym_return_val_size
*= 2) * sizeof (struct symbol
*);
4034 sym_return_val
= (struct symbol
**) xrealloc ((char *) sym_return_val
, newsize
);
4036 sym_return_val
[sym_return_val_index
++] = sym
;
4037 sym_return_val
[sym_return_val_index
] = NULL
;
4040 /* Return a null-terminated list of pointers to function symbols that
4041 * match name of the supplied symbol FSYM.
4042 * This is used in finding all overloaded instances of a function name.
4043 * This has been modified from make_symbol_completion_list. */
4047 make_symbol_overload_list (struct symbol
*fsym
)
4049 register struct symbol
*sym
;
4050 register struct symtab
*s
;
4051 register struct partial_symtab
*ps
;
4052 register struct objfile
*objfile
;
4053 register struct block
*b
, *surrounding_static_block
= 0;
4055 /* The name we are completing on. */
4056 char *oload_name
= NULL
;
4057 /* Length of name. */
4058 int oload_name_len
= 0;
4060 /* Look for the symbol we are supposed to complete on. */
4062 oload_name
= remove_params (SYMBOL_DEMANGLED_NAME (fsym
));
4065 sym_return_val_size
= 1;
4066 sym_return_val
= (struct symbol
**) xmalloc (2 * sizeof (struct symbol
*));
4067 sym_return_val
[0] = fsym
;
4068 sym_return_val
[1] = NULL
;
4070 return sym_return_val
;
4072 oload_name_len
= strlen (oload_name
);
4074 sym_return_val_size
= 100;
4075 sym_return_val_index
= 0;
4076 sym_return_val
= (struct symbol
**) xmalloc ((sym_return_val_size
+ 1) * sizeof (struct symbol
*));
4077 sym_return_val
[0] = NULL
;
4079 /* Read in all partial symtabs containing a partial symbol named
4082 ALL_PSYMTABS (objfile
, ps
)
4084 struct partial_symbol
**psym
;
4086 /* If the psymtab's been read in we'll get it when we search
4087 through the blockvector. */
4091 if ((lookup_partial_symbol (ps
, oload_name
, NULL
, 1, VAR_NAMESPACE
)
4093 || (lookup_partial_symbol (ps
, oload_name
, NULL
, 0, VAR_NAMESPACE
)
4095 PSYMTAB_TO_SYMTAB (ps
);
4098 /* Search upwards from currently selected frame (so that we can
4099 complete on local vars. */
4101 for (b
= get_selected_block (0); b
!= NULL
; b
= BLOCK_SUPERBLOCK (b
))
4103 if (!BLOCK_SUPERBLOCK (b
))
4105 surrounding_static_block
= b
; /* For elimination of dups */
4108 /* Also catch fields of types defined in this places which match our
4109 text string. Only complete on types visible from current context. */
4111 ALL_BLOCK_SYMBOLS (b
, i
, sym
)
4113 overload_list_add_symbol (sym
, oload_name
);
4117 /* Go through the symtabs and check the externs and statics for
4118 symbols which match. */
4120 ALL_SYMTABS (objfile
, s
)
4123 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
4124 ALL_BLOCK_SYMBOLS (b
, i
, sym
)
4126 overload_list_add_symbol (sym
, oload_name
);
4130 ALL_SYMTABS (objfile
, s
)
4133 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
4134 /* Don't do this block twice. */
4135 if (b
== surrounding_static_block
)
4137 ALL_BLOCK_SYMBOLS (b
, i
, sym
)
4139 overload_list_add_symbol (sym
, oload_name
);
4145 return (sym_return_val
);
4148 /* End of overload resolution functions */
4150 struct symtabs_and_lines
4151 decode_line_spec (char *string
, int funfirstline
)
4153 struct symtabs_and_lines sals
;
4154 struct symtab_and_line cursal
;
4157 error ("Empty line specification.");
4159 /* We use whatever is set as the current source line. We do not try
4160 and get a default or it will recursively call us! */
4161 cursal
= get_current_source_symtab_and_line ();
4163 sals
= decode_line_1 (&string
, funfirstline
,
4164 cursal
.symtab
, cursal
.line
,
4168 error ("Junk at end of line specification: %s", string
);
4173 static char *name_of_main
;
4176 set_main_name (const char *name
)
4178 if (name_of_main
!= NULL
)
4180 xfree (name_of_main
);
4181 name_of_main
= NULL
;
4185 name_of_main
= xstrdup (name
);
4192 if (name_of_main
!= NULL
)
4193 return name_of_main
;
4200 _initialize_symtab (void)
4202 add_info ("variables", variables_info
,
4203 "All global and static variable names, or those matching REGEXP.");
4205 add_com ("whereis", class_info
, variables_info
,
4206 "All global and static variable names, or those matching REGEXP.");
4208 add_info ("functions", functions_info
,
4209 "All function names, or those matching REGEXP.");
4212 /* FIXME: This command has at least the following problems:
4213 1. It prints builtin types (in a very strange and confusing fashion).
4214 2. It doesn't print right, e.g. with
4215 typedef struct foo *FOO
4216 type_print prints "FOO" when we want to make it (in this situation)
4217 print "struct foo *".
4218 I also think "ptype" or "whatis" is more likely to be useful (but if
4219 there is much disagreement "info types" can be fixed). */
4220 add_info ("types", types_info
,
4221 "All type names, or those matching REGEXP.");
4223 add_info ("sources", sources_info
,
4224 "Source files in the program.");
4226 add_com ("rbreak", class_breakpoint
, rbreak_command
,
4227 "Set a breakpoint for all functions matching REGEXP.");
4231 add_com ("lf", class_info
, sources_info
, "Source files in the program");
4232 add_com ("lg", class_info
, variables_info
,
4233 "All global and static variable names, or those matching REGEXP.");
4236 /* Initialize the one built-in type that isn't language dependent... */
4237 builtin_type_error
= init_type (TYPE_CODE_ERROR
, 0, 0,
4238 "<unknown type>", (struct objfile
*) NULL
);