1 /* Symbol table lookup for the GNU debugger, GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008
5 Free Software Foundation, Inc.
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 3 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, see <http://www.gnu.org/licenses/>. */
32 #include "call-cmds.h"
33 #include "gdb_regex.h"
34 #include "expression.h"
40 #include "filenames.h" /* for FILENAME_CMP */
41 #include "objc-lang.h"
47 #include "gdb_obstack.h"
49 #include "dictionary.h"
51 #include <sys/types.h>
53 #include "gdb_string.h"
58 #include "gdb_assert.h"
61 /* Prototypes for local functions */
63 static void completion_list_add_name (char *, char *, int, char *, char *);
65 static void rbreak_command (char *, int);
67 static void types_info (char *, int);
69 static void functions_info (char *, int);
71 static void variables_info (char *, int);
73 static void sources_info (char *, int);
75 static void output_source_filename (const char *, int *);
77 static int find_line_common (struct linetable
*, int, int *);
79 /* This one is used by linespec.c */
81 char *operator_chars (char *p
, char **end
);
83 static struct symbol
*lookup_symbol_aux (const char *name
,
84 const char *linkage_name
,
85 const struct block
*block
,
86 const domain_enum domain
,
87 enum language language
,
88 int *is_a_field_of_this
,
89 struct symtab
**symtab
);
92 struct symbol
*lookup_symbol_aux_local (const char *name
,
93 const char *linkage_name
,
94 const struct block
*block
,
95 const domain_enum domain
,
96 struct symtab
**symtab
);
99 struct symbol
*lookup_symbol_aux_symtabs (int block_index
,
101 const char *linkage_name
,
102 const domain_enum domain
,
103 struct symtab
**symtab
);
106 struct symbol
*lookup_symbol_aux_psymtabs (int block_index
,
108 const char *linkage_name
,
109 const domain_enum domain
,
110 struct symtab
**symtab
);
112 static void fixup_section (struct general_symbol_info
*, struct objfile
*);
114 static int file_matches (char *, char **, int);
116 static void print_symbol_info (domain_enum
,
117 struct symtab
*, struct symbol
*, int, char *);
119 static void print_msymbol_info (struct minimal_symbol
*);
121 static void symtab_symbol_info (char *, domain_enum
, int);
123 void _initialize_symtab (void);
127 /* Allow the user to configure the debugger behavior with respect
128 to multiple-choice menus when more than one symbol matches during
131 const char multiple_symbols_ask
[] = "ask";
132 const char multiple_symbols_all
[] = "all";
133 const char multiple_symbols_cancel
[] = "cancel";
134 static const char *multiple_symbols_modes
[] =
136 multiple_symbols_ask
,
137 multiple_symbols_all
,
138 multiple_symbols_cancel
,
141 static const char *multiple_symbols_mode
= multiple_symbols_all
;
143 /* Read-only accessor to AUTO_SELECT_MODE. */
146 multiple_symbols_select_mode (void)
148 return multiple_symbols_mode
;
151 /* The single non-language-specific builtin type */
152 struct type
*builtin_type_error
;
154 /* Block in which the most recently searched-for symbol was found.
155 Might be better to make this a parameter to lookup_symbol and
158 const struct block
*block_found
;
160 /* Check for a symtab of a specific name; first in symtabs, then in
161 psymtabs. *If* there is no '/' in the name, a match after a '/'
162 in the symtab filename will also work. */
165 lookup_symtab (const char *name
)
168 struct partial_symtab
*ps
;
169 struct objfile
*objfile
;
170 char *real_path
= NULL
;
171 char *full_path
= NULL
;
173 /* Here we are interested in canonicalizing an absolute path, not
174 absolutizing a relative path. */
175 if (IS_ABSOLUTE_PATH (name
))
177 full_path
= xfullpath (name
);
178 make_cleanup (xfree
, full_path
);
179 real_path
= gdb_realpath (name
);
180 make_cleanup (xfree
, real_path
);
185 /* First, search for an exact match */
187 ALL_SYMTABS (objfile
, s
)
189 if (FILENAME_CMP (name
, s
->filename
) == 0)
194 /* If the user gave us an absolute path, try to find the file in
195 this symtab and use its absolute path. */
197 if (full_path
!= NULL
)
199 const char *fp
= symtab_to_fullname (s
);
200 if (fp
!= NULL
&& FILENAME_CMP (full_path
, fp
) == 0)
206 if (real_path
!= NULL
)
208 char *fullname
= symtab_to_fullname (s
);
209 if (fullname
!= NULL
)
211 char *rp
= gdb_realpath (fullname
);
212 make_cleanup (xfree
, rp
);
213 if (FILENAME_CMP (real_path
, rp
) == 0)
221 /* Now, search for a matching tail (only if name doesn't have any dirs) */
223 if (lbasename (name
) == name
)
224 ALL_SYMTABS (objfile
, s
)
226 if (FILENAME_CMP (lbasename (s
->filename
), name
) == 0)
230 /* Same search rules as above apply here, but now we look thru the
233 ps
= lookup_partial_symtab (name
);
238 error (_("Internal: readin %s pst for `%s' found when no symtab found."),
241 s
= PSYMTAB_TO_SYMTAB (ps
);
246 /* At this point, we have located the psymtab for this file, but
247 the conversion to a symtab has failed. This usually happens
248 when we are looking up an include file. In this case,
249 PSYMTAB_TO_SYMTAB doesn't return a symtab, even though one has
250 been created. So, we need to run through the symtabs again in
251 order to find the file.
252 XXX - This is a crock, and should be fixed inside of the the
253 symbol parsing routines. */
257 /* Lookup the partial symbol table of a source file named NAME.
258 *If* there is no '/' in the name, a match after a '/'
259 in the psymtab filename will also work. */
261 struct partial_symtab
*
262 lookup_partial_symtab (const char *name
)
264 struct partial_symtab
*pst
;
265 struct objfile
*objfile
;
266 char *full_path
= NULL
;
267 char *real_path
= NULL
;
269 /* Here we are interested in canonicalizing an absolute path, not
270 absolutizing a relative path. */
271 if (IS_ABSOLUTE_PATH (name
))
273 full_path
= xfullpath (name
);
274 make_cleanup (xfree
, full_path
);
275 real_path
= gdb_realpath (name
);
276 make_cleanup (xfree
, real_path
);
279 ALL_PSYMTABS (objfile
, pst
)
281 if (FILENAME_CMP (name
, pst
->filename
) == 0)
286 /* If the user gave us an absolute path, try to find the file in
287 this symtab and use its absolute path. */
288 if (full_path
!= NULL
)
290 psymtab_to_fullname (pst
);
291 if (pst
->fullname
!= NULL
292 && FILENAME_CMP (full_path
, pst
->fullname
) == 0)
298 if (real_path
!= NULL
)
301 psymtab_to_fullname (pst
);
302 if (pst
->fullname
!= NULL
)
304 rp
= gdb_realpath (pst
->fullname
);
305 make_cleanup (xfree
, rp
);
307 if (rp
!= NULL
&& FILENAME_CMP (real_path
, rp
) == 0)
314 /* Now, search for a matching tail (only if name doesn't have any dirs) */
316 if (lbasename (name
) == name
)
317 ALL_PSYMTABS (objfile
, pst
)
319 if (FILENAME_CMP (lbasename (pst
->filename
), name
) == 0)
326 /* Mangle a GDB method stub type. This actually reassembles the pieces of the
327 full method name, which consist of the class name (from T), the unadorned
328 method name from METHOD_ID, and the signature for the specific overload,
329 specified by SIGNATURE_ID. Note that this function is g++ specific. */
332 gdb_mangle_name (struct type
*type
, int method_id
, int signature_id
)
334 int mangled_name_len
;
336 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
337 struct fn_field
*method
= &f
[signature_id
];
338 char *field_name
= TYPE_FN_FIELDLIST_NAME (type
, method_id
);
339 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, signature_id
);
340 char *newname
= type_name_no_tag (type
);
342 /* Does the form of physname indicate that it is the full mangled name
343 of a constructor (not just the args)? */
344 int is_full_physname_constructor
;
347 int is_destructor
= is_destructor_name (physname
);
348 /* Need a new type prefix. */
349 char *const_prefix
= method
->is_const
? "C" : "";
350 char *volatile_prefix
= method
->is_volatile
? "V" : "";
352 int len
= (newname
== NULL
? 0 : strlen (newname
));
354 /* Nothing to do if physname already contains a fully mangled v3 abi name
355 or an operator name. */
356 if ((physname
[0] == '_' && physname
[1] == 'Z')
357 || is_operator_name (field_name
))
358 return xstrdup (physname
);
360 is_full_physname_constructor
= is_constructor_name (physname
);
363 is_full_physname_constructor
|| (newname
&& strcmp (field_name
, newname
) == 0);
366 is_destructor
= (strncmp (physname
, "__dt", 4) == 0);
368 if (is_destructor
|| is_full_physname_constructor
)
370 mangled_name
= (char *) xmalloc (strlen (physname
) + 1);
371 strcpy (mangled_name
, physname
);
377 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
379 else if (physname
[0] == 't' || physname
[0] == 'Q')
381 /* The physname for template and qualified methods already includes
383 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
389 sprintf (buf
, "__%s%s%d", const_prefix
, volatile_prefix
, len
);
391 mangled_name_len
= ((is_constructor
? 0 : strlen (field_name
))
392 + strlen (buf
) + len
+ strlen (physname
) + 1);
395 mangled_name
= (char *) xmalloc (mangled_name_len
);
397 mangled_name
[0] = '\0';
399 strcpy (mangled_name
, field_name
);
401 strcat (mangled_name
, buf
);
402 /* If the class doesn't have a name, i.e. newname NULL, then we just
403 mangle it using 0 for the length of the class. Thus it gets mangled
404 as something starting with `::' rather than `classname::'. */
406 strcat (mangled_name
, newname
);
408 strcat (mangled_name
, physname
);
409 return (mangled_name
);
413 /* Initialize the language dependent portion of a symbol
414 depending upon the language for the symbol. */
416 symbol_init_language_specific (struct general_symbol_info
*gsymbol
,
417 enum language language
)
419 gsymbol
->language
= language
;
420 if (gsymbol
->language
== language_cplus
421 || gsymbol
->language
== language_java
422 || gsymbol
->language
== language_objc
)
424 gsymbol
->language_specific
.cplus_specific
.demangled_name
= NULL
;
428 memset (&gsymbol
->language_specific
, 0,
429 sizeof (gsymbol
->language_specific
));
433 /* Functions to initialize a symbol's mangled name. */
435 /* Create the hash table used for demangled names. Each hash entry is
436 a pair of strings; one for the mangled name and one for the demangled
437 name. The entry is hashed via just the mangled name. */
440 create_demangled_names_hash (struct objfile
*objfile
)
442 /* Choose 256 as the starting size of the hash table, somewhat arbitrarily.
443 The hash table code will round this up to the next prime number.
444 Choosing a much larger table size wastes memory, and saves only about
445 1% in symbol reading. */
447 objfile
->demangled_names_hash
= htab_create_alloc
448 (256, htab_hash_string
, (int (*) (const void *, const void *)) streq
,
449 NULL
, xcalloc
, xfree
);
452 /* Try to determine the demangled name for a symbol, based on the
453 language of that symbol. If the language is set to language_auto,
454 it will attempt to find any demangling algorithm that works and
455 then set the language appropriately. The returned name is allocated
456 by the demangler and should be xfree'd. */
459 symbol_find_demangled_name (struct general_symbol_info
*gsymbol
,
462 char *demangled
= NULL
;
464 if (gsymbol
->language
== language_unknown
)
465 gsymbol
->language
= language_auto
;
467 if (gsymbol
->language
== language_objc
468 || gsymbol
->language
== language_auto
)
471 objc_demangle (mangled
, 0);
472 if (demangled
!= NULL
)
474 gsymbol
->language
= language_objc
;
478 if (gsymbol
->language
== language_cplus
479 || gsymbol
->language
== language_auto
)
482 cplus_demangle (mangled
, DMGL_PARAMS
| DMGL_ANSI
);
483 if (demangled
!= NULL
)
485 gsymbol
->language
= language_cplus
;
489 if (gsymbol
->language
== language_java
)
492 cplus_demangle (mangled
,
493 DMGL_PARAMS
| DMGL_ANSI
| DMGL_JAVA
);
494 if (demangled
!= NULL
)
496 gsymbol
->language
= language_java
;
503 /* Set both the mangled and demangled (if any) names for GSYMBOL based
504 on LINKAGE_NAME and LEN. The hash table corresponding to OBJFILE
505 is used, and the memory comes from that objfile's objfile_obstack.
506 LINKAGE_NAME is copied, so the pointer can be discarded after
507 calling this function. */
509 /* We have to be careful when dealing with Java names: when we run
510 into a Java minimal symbol, we don't know it's a Java symbol, so it
511 gets demangled as a C++ name. This is unfortunate, but there's not
512 much we can do about it: but when demangling partial symbols and
513 regular symbols, we'd better not reuse the wrong demangled name.
514 (See PR gdb/1039.) We solve this by putting a distinctive prefix
515 on Java names when storing them in the hash table. */
517 /* FIXME: carlton/2003-03-13: This is an unfortunate situation. I
518 don't mind the Java prefix so much: different languages have
519 different demangling requirements, so it's only natural that we
520 need to keep language data around in our demangling cache. But
521 it's not good that the minimal symbol has the wrong demangled name.
522 Unfortunately, I can't think of any easy solution to that
525 #define JAVA_PREFIX "##JAVA$$"
526 #define JAVA_PREFIX_LEN 8
529 symbol_set_names (struct general_symbol_info
*gsymbol
,
530 const char *linkage_name
, int len
, struct objfile
*objfile
)
533 /* A 0-terminated copy of the linkage name. */
534 const char *linkage_name_copy
;
535 /* A copy of the linkage name that might have a special Java prefix
536 added to it, for use when looking names up in the hash table. */
537 const char *lookup_name
;
538 /* The length of lookup_name. */
541 if (objfile
->demangled_names_hash
== NULL
)
542 create_demangled_names_hash (objfile
);
544 if (gsymbol
->language
== language_ada
)
546 /* In Ada, we do the symbol lookups using the mangled name, so
547 we can save some space by not storing the demangled name.
549 As a side note, we have also observed some overlap between
550 the C++ mangling and Ada mangling, similarly to what has
551 been observed with Java. Because we don't store the demangled
552 name with the symbol, we don't need to use the same trick
554 gsymbol
->name
= obstack_alloc (&objfile
->objfile_obstack
, len
+ 1);
555 memcpy (gsymbol
->name
, linkage_name
, len
);
556 gsymbol
->name
[len
] = '\0';
557 gsymbol
->language_specific
.cplus_specific
.demangled_name
= NULL
;
562 /* The stabs reader generally provides names that are not
563 NUL-terminated; most of the other readers don't do this, so we
564 can just use the given copy, unless we're in the Java case. */
565 if (gsymbol
->language
== language_java
)
568 lookup_len
= len
+ JAVA_PREFIX_LEN
;
570 alloc_name
= alloca (lookup_len
+ 1);
571 memcpy (alloc_name
, JAVA_PREFIX
, JAVA_PREFIX_LEN
);
572 memcpy (alloc_name
+ JAVA_PREFIX_LEN
, linkage_name
, len
);
573 alloc_name
[lookup_len
] = '\0';
575 lookup_name
= alloc_name
;
576 linkage_name_copy
= alloc_name
+ JAVA_PREFIX_LEN
;
578 else if (linkage_name
[len
] != '\0')
583 alloc_name
= alloca (lookup_len
+ 1);
584 memcpy (alloc_name
, linkage_name
, len
);
585 alloc_name
[lookup_len
] = '\0';
587 lookup_name
= alloc_name
;
588 linkage_name_copy
= alloc_name
;
593 lookup_name
= linkage_name
;
594 linkage_name_copy
= linkage_name
;
597 slot
= (char **) htab_find_slot (objfile
->demangled_names_hash
,
598 lookup_name
, INSERT
);
600 /* If this name is not in the hash table, add it. */
603 char *demangled_name
= symbol_find_demangled_name (gsymbol
,
605 int demangled_len
= demangled_name
? strlen (demangled_name
) : 0;
607 /* If there is a demangled name, place it right after the mangled name.
608 Otherwise, just place a second zero byte after the end of the mangled
610 *slot
= obstack_alloc (&objfile
->objfile_obstack
,
611 lookup_len
+ demangled_len
+ 2);
612 memcpy (*slot
, lookup_name
, lookup_len
+ 1);
613 if (demangled_name
!= NULL
)
615 memcpy (*slot
+ lookup_len
+ 1, demangled_name
, demangled_len
+ 1);
616 xfree (demangled_name
);
619 (*slot
)[lookup_len
+ 1] = '\0';
622 gsymbol
->name
= *slot
+ lookup_len
- len
;
623 if ((*slot
)[lookup_len
+ 1] != '\0')
624 gsymbol
->language_specific
.cplus_specific
.demangled_name
625 = &(*slot
)[lookup_len
+ 1];
627 gsymbol
->language_specific
.cplus_specific
.demangled_name
= NULL
;
630 /* Return the source code name of a symbol. In languages where
631 demangling is necessary, this is the demangled name. */
634 symbol_natural_name (const struct general_symbol_info
*gsymbol
)
636 switch (gsymbol
->language
)
641 if (gsymbol
->language_specific
.cplus_specific
.demangled_name
!= NULL
)
642 return gsymbol
->language_specific
.cplus_specific
.demangled_name
;
645 if (gsymbol
->language_specific
.cplus_specific
.demangled_name
!= NULL
)
646 return gsymbol
->language_specific
.cplus_specific
.demangled_name
;
648 return ada_decode_symbol (gsymbol
);
653 return gsymbol
->name
;
656 /* Return the demangled name for a symbol based on the language for
657 that symbol. If no demangled name exists, return NULL. */
659 symbol_demangled_name (struct general_symbol_info
*gsymbol
)
661 switch (gsymbol
->language
)
666 if (gsymbol
->language_specific
.cplus_specific
.demangled_name
!= NULL
)
667 return gsymbol
->language_specific
.cplus_specific
.demangled_name
;
670 if (gsymbol
->language_specific
.cplus_specific
.demangled_name
!= NULL
)
671 return gsymbol
->language_specific
.cplus_specific
.demangled_name
;
673 return ada_decode_symbol (gsymbol
);
681 /* Return the search name of a symbol---generally the demangled or
682 linkage name of the symbol, depending on how it will be searched for.
683 If there is no distinct demangled name, then returns the same value
684 (same pointer) as SYMBOL_LINKAGE_NAME. */
686 symbol_search_name (const struct general_symbol_info
*gsymbol
)
688 if (gsymbol
->language
== language_ada
)
689 return gsymbol
->name
;
691 return symbol_natural_name (gsymbol
);
694 /* Initialize the structure fields to zero values. */
696 init_sal (struct symtab_and_line
*sal
)
703 sal
->explicit_pc
= 0;
704 sal
->explicit_line
= 0;
708 /* Return 1 if the two sections are the same, or if they could
709 plausibly be copies of each other, one in an original object
710 file and another in a separated debug file. */
713 matching_bfd_sections (asection
*first
, asection
*second
)
717 /* If they're the same section, then they match. */
721 /* If either is NULL, give up. */
722 if (first
== NULL
|| second
== NULL
)
725 /* This doesn't apply to absolute symbols. */
726 if (first
->owner
== NULL
|| second
->owner
== NULL
)
729 /* If they're in the same object file, they must be different sections. */
730 if (first
->owner
== second
->owner
)
733 /* Check whether the two sections are potentially corresponding. They must
734 have the same size, address, and name. We can't compare section indexes,
735 which would be more reliable, because some sections may have been
737 if (bfd_get_section_size (first
) != bfd_get_section_size (second
))
740 /* In-memory addresses may start at a different offset, relativize them. */
741 if (bfd_get_section_vma (first
->owner
, first
)
742 - bfd_get_start_address (first
->owner
)
743 != bfd_get_section_vma (second
->owner
, second
)
744 - bfd_get_start_address (second
->owner
))
747 if (bfd_get_section_name (first
->owner
, first
) == NULL
748 || bfd_get_section_name (second
->owner
, second
) == NULL
749 || strcmp (bfd_get_section_name (first
->owner
, first
),
750 bfd_get_section_name (second
->owner
, second
)) != 0)
753 /* Otherwise check that they are in corresponding objfiles. */
756 if (obj
->obfd
== first
->owner
)
758 gdb_assert (obj
!= NULL
);
760 if (obj
->separate_debug_objfile
!= NULL
761 && obj
->separate_debug_objfile
->obfd
== second
->owner
)
763 if (obj
->separate_debug_objfile_backlink
!= NULL
764 && obj
->separate_debug_objfile_backlink
->obfd
== second
->owner
)
770 /* Find which partial symtab contains PC and SECTION. Return 0 if
771 none. We return the psymtab that contains a symbol whose address
772 exactly matches PC, or, if we cannot find an exact match, the
773 psymtab that contains a symbol whose address is closest to PC. */
774 struct partial_symtab
*
775 find_pc_sect_psymtab (CORE_ADDR pc
, asection
*section
)
777 struct partial_symtab
*pst
;
778 struct objfile
*objfile
;
779 struct minimal_symbol
*msymbol
;
781 /* If we know that this is not a text address, return failure. This is
782 necessary because we loop based on texthigh and textlow, which do
783 not include the data ranges. */
784 msymbol
= lookup_minimal_symbol_by_pc_section (pc
, section
);
786 && (msymbol
->type
== mst_data
787 || msymbol
->type
== mst_bss
788 || msymbol
->type
== mst_abs
789 || msymbol
->type
== mst_file_data
790 || msymbol
->type
== mst_file_bss
))
793 ALL_PSYMTABS (objfile
, pst
)
795 if (pc
>= pst
->textlow
&& pc
< pst
->texthigh
)
797 struct partial_symtab
*tpst
;
798 struct partial_symtab
*best_pst
= pst
;
799 CORE_ADDR best_addr
= pst
->textlow
;
801 /* An objfile that has its functions reordered might have
802 many partial symbol tables containing the PC, but
803 we want the partial symbol table that contains the
804 function containing the PC. */
805 if (!(objfile
->flags
& OBJF_REORDERED
) &&
806 section
== 0) /* can't validate section this way */
812 /* The code range of partial symtabs sometimes overlap, so, in
813 the loop below, we need to check all partial symtabs and
814 find the one that fits better for the given PC address. We
815 select the partial symtab that contains a symbol whose
816 address is closest to the PC address. By closest we mean
817 that find_pc_sect_symbol returns the symbol with address
818 that is closest and still less than the given PC. */
819 for (tpst
= pst
; tpst
!= NULL
; tpst
= tpst
->next
)
821 if (pc
>= tpst
->textlow
&& pc
< tpst
->texthigh
)
823 struct partial_symbol
*p
;
826 /* NOTE: This assumes that every psymbol has a
827 corresponding msymbol, which is not necessarily
828 true; the debug info might be much richer than the
829 object's symbol table. */
830 p
= find_pc_sect_psymbol (tpst
, pc
, section
);
832 && SYMBOL_VALUE_ADDRESS (p
)
833 == SYMBOL_VALUE_ADDRESS (msymbol
))
836 /* Also accept the textlow value of a psymtab as a
837 "symbol", to provide some support for partial
838 symbol tables with line information but no debug
839 symbols (e.g. those produced by an assembler). */
841 this_addr
= SYMBOL_VALUE_ADDRESS (p
);
843 this_addr
= tpst
->textlow
;
845 /* Check whether it is closer than our current
846 BEST_ADDR. Since this symbol address is
847 necessarily lower or equal to PC, the symbol closer
848 to PC is the symbol which address is the highest.
849 This way we return the psymtab which contains such
850 best match symbol. This can help in cases where the
851 symbol information/debuginfo is not complete, like
852 for instance on IRIX6 with gcc, where no debug info
853 is emitted for statics. (See also the nodebug.exp
855 if (this_addr
> best_addr
)
857 best_addr
= this_addr
;
868 /* Find which partial symtab contains PC. Return 0 if none.
869 Backward compatibility, no section */
871 struct partial_symtab
*
872 find_pc_psymtab (CORE_ADDR pc
)
874 return find_pc_sect_psymtab (pc
, find_pc_mapped_section (pc
));
877 /* Find which partial symbol within a psymtab matches PC and SECTION.
878 Return 0 if none. Check all psymtabs if PSYMTAB is 0. */
880 struct partial_symbol
*
881 find_pc_sect_psymbol (struct partial_symtab
*psymtab
, CORE_ADDR pc
,
884 struct partial_symbol
*best
= NULL
, *p
, **pp
;
888 psymtab
= find_pc_sect_psymtab (pc
, section
);
892 /* Cope with programs that start at address 0 */
893 best_pc
= (psymtab
->textlow
!= 0) ? psymtab
->textlow
- 1 : 0;
895 /* Search the global symbols as well as the static symbols, so that
896 find_pc_partial_function doesn't use a minimal symbol and thus
897 cache a bad endaddr. */
898 for (pp
= psymtab
->objfile
->global_psymbols
.list
+ psymtab
->globals_offset
;
899 (pp
- (psymtab
->objfile
->global_psymbols
.list
+ psymtab
->globals_offset
)
900 < psymtab
->n_global_syms
);
904 if (SYMBOL_DOMAIN (p
) == VAR_DOMAIN
905 && SYMBOL_CLASS (p
) == LOC_BLOCK
906 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
907 && (SYMBOL_VALUE_ADDRESS (p
) > best_pc
908 || (psymtab
->textlow
== 0
909 && best_pc
== 0 && SYMBOL_VALUE_ADDRESS (p
) == 0)))
911 if (section
) /* match on a specific section */
913 fixup_psymbol_section (p
, psymtab
->objfile
);
914 if (!matching_bfd_sections (SYMBOL_BFD_SECTION (p
), section
))
917 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
922 for (pp
= psymtab
->objfile
->static_psymbols
.list
+ psymtab
->statics_offset
;
923 (pp
- (psymtab
->objfile
->static_psymbols
.list
+ psymtab
->statics_offset
)
924 < psymtab
->n_static_syms
);
928 if (SYMBOL_DOMAIN (p
) == VAR_DOMAIN
929 && SYMBOL_CLASS (p
) == LOC_BLOCK
930 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
931 && (SYMBOL_VALUE_ADDRESS (p
) > best_pc
932 || (psymtab
->textlow
== 0
933 && best_pc
== 0 && SYMBOL_VALUE_ADDRESS (p
) == 0)))
935 if (section
) /* match on a specific section */
937 fixup_psymbol_section (p
, psymtab
->objfile
);
938 if (!matching_bfd_sections (SYMBOL_BFD_SECTION (p
), section
))
941 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
949 /* Find which partial symbol within a psymtab matches PC. Return 0 if none.
950 Check all psymtabs if PSYMTAB is 0. Backwards compatibility, no section. */
952 struct partial_symbol
*
953 find_pc_psymbol (struct partial_symtab
*psymtab
, CORE_ADDR pc
)
955 return find_pc_sect_psymbol (psymtab
, pc
, find_pc_mapped_section (pc
));
958 /* Debug symbols usually don't have section information. We need to dig that
959 out of the minimal symbols and stash that in the debug symbol. */
962 fixup_section (struct general_symbol_info
*ginfo
, struct objfile
*objfile
)
964 struct minimal_symbol
*msym
;
965 msym
= lookup_minimal_symbol (ginfo
->name
, NULL
, objfile
);
967 /* First, check whether a minimal symbol with the same name exists
968 and points to the same address. The address check is required
969 e.g. on PowerPC64, where the minimal symbol for a function will
970 point to the function descriptor, while the debug symbol will
971 point to the actual function code. */
973 && SYMBOL_VALUE_ADDRESS (msym
) == ginfo
->value
.address
)
975 ginfo
->bfd_section
= SYMBOL_BFD_SECTION (msym
);
976 ginfo
->section
= SYMBOL_SECTION (msym
);
980 /* Static, function-local variables do appear in the linker
981 (minimal) symbols, but are frequently given names that won't
982 be found via lookup_minimal_symbol(). E.g., it has been
983 observed in frv-uclinux (ELF) executables that a static,
984 function-local variable named "foo" might appear in the
985 linker symbols as "foo.6" or "foo.3". Thus, there is no
986 point in attempting to extend the lookup-by-name mechanism to
987 handle this case due to the fact that there can be multiple
990 So, instead, search the section table when lookup by name has
991 failed. The ``addr'' and ``endaddr'' fields may have already
992 been relocated. If so, the relocation offset (i.e. the
993 ANOFFSET value) needs to be subtracted from these values when
994 performing the comparison. We unconditionally subtract it,
995 because, when no relocation has been performed, the ANOFFSET
996 value will simply be zero.
998 The address of the symbol whose section we're fixing up HAS
999 NOT BEEN adjusted (relocated) yet. It can't have been since
1000 the section isn't yet known and knowing the section is
1001 necessary in order to add the correct relocation value. In
1002 other words, we wouldn't even be in this function (attempting
1003 to compute the section) if it were already known.
1005 Note that it is possible to search the minimal symbols
1006 (subtracting the relocation value if necessary) to find the
1007 matching minimal symbol, but this is overkill and much less
1008 efficient. It is not necessary to find the matching minimal
1009 symbol, only its section.
1011 Note that this technique (of doing a section table search)
1012 can fail when unrelocated section addresses overlap. For
1013 this reason, we still attempt a lookup by name prior to doing
1014 a search of the section table. */
1017 struct obj_section
*s
;
1019 addr
= ginfo
->value
.address
;
1021 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1023 int idx
= s
->the_bfd_section
->index
;
1024 CORE_ADDR offset
= ANOFFSET (objfile
->section_offsets
, idx
);
1026 if (s
->addr
- offset
<= addr
&& addr
< s
->endaddr
- offset
)
1028 ginfo
->bfd_section
= s
->the_bfd_section
;
1029 ginfo
->section
= idx
;
1037 fixup_symbol_section (struct symbol
*sym
, struct objfile
*objfile
)
1042 if (SYMBOL_BFD_SECTION (sym
))
1045 fixup_section (&sym
->ginfo
, objfile
);
1050 struct partial_symbol
*
1051 fixup_psymbol_section (struct partial_symbol
*psym
, struct objfile
*objfile
)
1056 if (SYMBOL_BFD_SECTION (psym
))
1059 fixup_section (&psym
->ginfo
, objfile
);
1064 /* Find the definition for a specified symbol name NAME
1065 in domain DOMAIN, visible from lexical block BLOCK.
1066 Returns the struct symbol pointer, or zero if no symbol is found.
1067 If SYMTAB is non-NULL, store the symbol table in which the
1068 symbol was found there, or NULL if not found.
1069 C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
1070 NAME is a field of the current implied argument `this'. If so set
1071 *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
1072 BLOCK_FOUND is set to the block in which NAME is found (in the case of
1073 a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
1075 /* This function has a bunch of loops in it and it would seem to be
1076 attractive to put in some QUIT's (though I'm not really sure
1077 whether it can run long enough to be really important). But there
1078 are a few calls for which it would appear to be bad news to quit
1079 out of here: find_proc_desc in alpha-tdep.c and mips-tdep.c. (Note
1080 that there is C++ code below which can error(), but that probably
1081 doesn't affect these calls since they are looking for a known
1082 variable and thus can probably assume it will never hit the C++
1086 lookup_symbol_in_language (const char *name
, const struct block
*block
,
1087 const domain_enum domain
, enum language lang
,
1088 int *is_a_field_of_this
,
1089 struct symtab
**symtab
)
1091 char *demangled_name
= NULL
;
1092 const char *modified_name
= NULL
;
1093 const char *mangled_name
= NULL
;
1094 int needtofreename
= 0;
1095 struct symbol
*returnval
;
1097 modified_name
= name
;
1099 /* If we are using C++ or Java, demangle the name before doing a lookup, so
1100 we can always binary search. */
1101 if (lang
== language_cplus
)
1103 demangled_name
= cplus_demangle (name
, DMGL_ANSI
| DMGL_PARAMS
);
1106 mangled_name
= name
;
1107 modified_name
= demangled_name
;
1111 else if (lang
== language_java
)
1113 demangled_name
= cplus_demangle (name
,
1114 DMGL_ANSI
| DMGL_PARAMS
| DMGL_JAVA
);
1117 mangled_name
= name
;
1118 modified_name
= demangled_name
;
1123 if (case_sensitivity
== case_sensitive_off
)
1128 len
= strlen (name
);
1129 copy
= (char *) alloca (len
+ 1);
1130 for (i
= 0; i
< len
; i
++)
1131 copy
[i
] = tolower (name
[i
]);
1133 modified_name
= copy
;
1136 returnval
= lookup_symbol_aux (modified_name
, mangled_name
, block
,
1138 is_a_field_of_this
, symtab
);
1140 xfree (demangled_name
);
1142 /* Override the returned symtab with the symbol's specific one. */
1143 if (returnval
!= NULL
&& symtab
!= NULL
)
1144 *symtab
= SYMBOL_SYMTAB (returnval
);
1149 /* Behave like lookup_symbol_in_language, but performed with the
1150 current language. */
1153 lookup_symbol (const char *name
, const struct block
*block
,
1154 domain_enum domain
, int *is_a_field_of_this
,
1155 struct symtab
**symtab
)
1157 return lookup_symbol_in_language (name
, block
, domain
,
1158 current_language
->la_language
,
1159 is_a_field_of_this
, symtab
);
1162 /* Behave like lookup_symbol except that NAME is the natural name
1163 of the symbol that we're looking for and, if LINKAGE_NAME is
1164 non-NULL, ensure that the symbol's linkage name matches as
1167 static struct symbol
*
1168 lookup_symbol_aux (const char *name
, const char *linkage_name
,
1169 const struct block
*block
, const domain_enum domain
,
1170 enum language language
,
1171 int *is_a_field_of_this
, struct symtab
**symtab
)
1174 const struct language_defn
*langdef
;
1176 /* Make sure we do something sensible with is_a_field_of_this, since
1177 the callers that set this parameter to some non-null value will
1178 certainly use it later and expect it to be either 0 or 1.
1179 If we don't set it, the contents of is_a_field_of_this are
1181 if (is_a_field_of_this
!= NULL
)
1182 *is_a_field_of_this
= 0;
1184 /* Search specified block and its superiors. Don't search
1185 STATIC_BLOCK or GLOBAL_BLOCK. */
1187 sym
= lookup_symbol_aux_local (name
, linkage_name
, block
, domain
,
1192 /* If requested to do so by the caller and if appropriate for LANGUAGE,
1193 check to see if NAME is a field of `this'. */
1195 langdef
= language_def (language
);
1197 if (langdef
->la_name_of_this
!= NULL
&& is_a_field_of_this
!= NULL
1200 struct symbol
*sym
= NULL
;
1201 /* 'this' is only defined in the function's block, so find the
1202 enclosing function block. */
1203 for (; block
&& !BLOCK_FUNCTION (block
);
1204 block
= BLOCK_SUPERBLOCK (block
));
1206 if (block
&& !dict_empty (BLOCK_DICT (block
)))
1207 sym
= lookup_block_symbol (block
, langdef
->la_name_of_this
,
1211 struct type
*t
= sym
->type
;
1213 /* I'm not really sure that type of this can ever
1214 be typedefed; just be safe. */
1216 if (TYPE_CODE (t
) == TYPE_CODE_PTR
1217 || TYPE_CODE (t
) == TYPE_CODE_REF
)
1218 t
= TYPE_TARGET_TYPE (t
);
1220 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
1221 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1222 error (_("Internal error: `%s' is not an aggregate"),
1223 langdef
->la_name_of_this
);
1225 if (check_field (t
, name
))
1227 *is_a_field_of_this
= 1;
1235 /* Now do whatever is appropriate for LANGUAGE to look
1236 up static and global variables. */
1238 sym
= langdef
->la_lookup_symbol_nonlocal (name
, linkage_name
,
1239 block
, domain
, symtab
);
1243 /* Now search all static file-level symbols. Not strictly correct,
1244 but more useful than an error. Do the symtabs first, then check
1245 the psymtabs. If a psymtab indicates the existence of the
1246 desired name as a file-level static, then do psymtab-to-symtab
1247 conversion on the fly and return the found symbol. */
1249 sym
= lookup_symbol_aux_symtabs (STATIC_BLOCK
, name
, linkage_name
,
1254 sym
= lookup_symbol_aux_psymtabs (STATIC_BLOCK
, name
, linkage_name
,
1264 /* Check to see if the symbol is defined in BLOCK or its superiors.
1265 Don't search STATIC_BLOCK or GLOBAL_BLOCK. */
1267 static struct symbol
*
1268 lookup_symbol_aux_local (const char *name
, const char *linkage_name
,
1269 const struct block
*block
,
1270 const domain_enum domain
,
1271 struct symtab
**symtab
)
1274 const struct block
*static_block
= block_static_block (block
);
1276 /* Check if either no block is specified or it's a global block. */
1278 if (static_block
== NULL
)
1281 while (block
!= static_block
)
1283 sym
= lookup_symbol_aux_block (name
, linkage_name
, block
, domain
,
1287 block
= BLOCK_SUPERBLOCK (block
);
1290 /* We've reached the static block without finding a result. */
1295 /* Look up OBJFILE to BLOCK. */
1297 static struct objfile
*
1298 lookup_objfile_from_block (const struct block
*block
)
1300 struct objfile
*obj
;
1306 block
= block_global_block (block
);
1307 /* Go through SYMTABS. */
1308 ALL_SYMTABS (obj
, s
)
1309 if (block
== BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
))
1315 /* Look up a symbol in a block; if found, locate its symtab, fixup the
1316 symbol, and set block_found appropriately. */
1319 lookup_symbol_aux_block (const char *name
, const char *linkage_name
,
1320 const struct block
*block
,
1321 const domain_enum domain
,
1322 struct symtab
**symtab
)
1325 struct objfile
*objfile
= NULL
;
1326 struct blockvector
*bv
;
1328 struct symtab
*s
= NULL
;
1330 sym
= lookup_block_symbol (block
, name
, linkage_name
, domain
);
1333 block_found
= block
;
1336 /* Search the list of symtabs for one which contains the
1337 address of the start of this block. */
1338 ALL_PRIMARY_SYMTABS (objfile
, s
)
1340 bv
= BLOCKVECTOR (s
);
1341 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1342 if (BLOCK_START (b
) <= BLOCK_START (block
)
1343 && BLOCK_END (b
) > BLOCK_START (block
))
1350 return fixup_symbol_section (sym
, objfile
);
1356 /* Check all global symbols in OBJFILE in symtabs and
1360 lookup_global_symbol_from_objfile (const struct objfile
*objfile
,
1362 const char *linkage_name
,
1363 const domain_enum domain
,
1364 struct symtab
**symtab
)
1367 struct blockvector
*bv
;
1368 const struct block
*block
;
1370 struct partial_symtab
*ps
;
1372 /* Go through symtabs. */
1373 ALL_OBJFILE_SYMTABS (objfile
, s
)
1375 bv
= BLOCKVECTOR (s
);
1376 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1377 sym
= lookup_block_symbol (block
, name
, linkage_name
, domain
);
1380 block_found
= block
;
1383 return fixup_symbol_section (sym
, (struct objfile
*)objfile
);
1387 /* Now go through psymtabs. */
1388 ALL_OBJFILE_PSYMTABS (objfile
, ps
)
1391 && lookup_partial_symbol (ps
, name
, linkage_name
,
1394 s
= PSYMTAB_TO_SYMTAB (ps
);
1395 bv
= BLOCKVECTOR (s
);
1396 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1397 sym
= lookup_block_symbol (block
, name
, linkage_name
, domain
);
1400 return fixup_symbol_section (sym
, (struct objfile
*)objfile
);
1404 if (objfile
->separate_debug_objfile
)
1405 return lookup_global_symbol_from_objfile (objfile
->separate_debug_objfile
,
1406 name
, linkage_name
, domain
,
1412 /* Check to see if the symbol is defined in one of the symtabs.
1413 BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
1414 depending on whether or not we want to search global symbols or
1417 static struct symbol
*
1418 lookup_symbol_aux_symtabs (int block_index
,
1419 const char *name
, const char *linkage_name
,
1420 const domain_enum domain
,
1421 struct symtab
**symtab
)
1424 struct objfile
*objfile
;
1425 struct blockvector
*bv
;
1426 const struct block
*block
;
1429 ALL_PRIMARY_SYMTABS (objfile
, s
)
1431 bv
= BLOCKVECTOR (s
);
1432 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
1433 sym
= lookup_block_symbol (block
, name
, linkage_name
, domain
);
1436 block_found
= block
;
1439 return fixup_symbol_section (sym
, objfile
);
1446 /* Check to see if the symbol is defined in one of the partial
1447 symtabs. BLOCK_INDEX should be either GLOBAL_BLOCK or
1448 STATIC_BLOCK, depending on whether or not we want to search global
1449 symbols or static symbols. */
1451 static struct symbol
*
1452 lookup_symbol_aux_psymtabs (int block_index
, const char *name
,
1453 const char *linkage_name
,
1454 const domain_enum domain
,
1455 struct symtab
**symtab
)
1458 struct objfile
*objfile
;
1459 struct blockvector
*bv
;
1460 const struct block
*block
;
1461 struct partial_symtab
*ps
;
1463 const int psymtab_index
= (block_index
== GLOBAL_BLOCK
? 1 : 0);
1465 ALL_PSYMTABS (objfile
, ps
)
1468 && lookup_partial_symbol (ps
, name
, linkage_name
,
1469 psymtab_index
, domain
))
1471 s
= PSYMTAB_TO_SYMTAB (ps
);
1472 bv
= BLOCKVECTOR (s
);
1473 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
1474 sym
= lookup_block_symbol (block
, name
, linkage_name
, domain
);
1477 /* This shouldn't be necessary, but as a last resort try
1478 looking in the statics even though the psymtab claimed
1479 the symbol was global, or vice-versa. It's possible
1480 that the psymtab gets it wrong in some cases. */
1482 /* FIXME: carlton/2002-09-30: Should we really do that?
1483 If that happens, isn't it likely to be a GDB error, in
1484 which case we should fix the GDB error rather than
1485 silently dealing with it here? So I'd vote for
1486 removing the check for the symbol in the other
1488 block
= BLOCKVECTOR_BLOCK (bv
,
1489 block_index
== GLOBAL_BLOCK
?
1490 STATIC_BLOCK
: GLOBAL_BLOCK
);
1491 sym
= lookup_block_symbol (block
, name
, linkage_name
, domain
);
1493 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>)."),
1494 block_index
== GLOBAL_BLOCK
? "global" : "static",
1495 name
, ps
->filename
, name
, name
);
1499 return fixup_symbol_section (sym
, objfile
);
1506 /* A default version of lookup_symbol_nonlocal for use by languages
1507 that can't think of anything better to do. This implements the C
1511 basic_lookup_symbol_nonlocal (const char *name
,
1512 const char *linkage_name
,
1513 const struct block
*block
,
1514 const domain_enum domain
,
1515 struct symtab
**symtab
)
1519 /* NOTE: carlton/2003-05-19: The comments below were written when
1520 this (or what turned into this) was part of lookup_symbol_aux;
1521 I'm much less worried about these questions now, since these
1522 decisions have turned out well, but I leave these comments here
1525 /* NOTE: carlton/2002-12-05: There is a question as to whether or
1526 not it would be appropriate to search the current global block
1527 here as well. (That's what this code used to do before the
1528 is_a_field_of_this check was moved up.) On the one hand, it's
1529 redundant with the lookup_symbol_aux_symtabs search that happens
1530 next. On the other hand, if decode_line_1 is passed an argument
1531 like filename:var, then the user presumably wants 'var' to be
1532 searched for in filename. On the third hand, there shouldn't be
1533 multiple global variables all of which are named 'var', and it's
1534 not like decode_line_1 has ever restricted its search to only
1535 global variables in a single filename. All in all, only
1536 searching the static block here seems best: it's correct and it's
1539 /* NOTE: carlton/2002-12-05: There's also a possible performance
1540 issue here: if you usually search for global symbols in the
1541 current file, then it would be slightly better to search the
1542 current global block before searching all the symtabs. But there
1543 are other factors that have a much greater effect on performance
1544 than that one, so I don't think we should worry about that for
1547 sym
= lookup_symbol_static (name
, linkage_name
, block
, domain
, symtab
);
1551 return lookup_symbol_global (name
, linkage_name
, block
, domain
, symtab
);
1554 /* Lookup a symbol in the static block associated to BLOCK, if there
1555 is one; do nothing if BLOCK is NULL or a global block. */
1558 lookup_symbol_static (const char *name
,
1559 const char *linkage_name
,
1560 const struct block
*block
,
1561 const domain_enum domain
,
1562 struct symtab
**symtab
)
1564 const struct block
*static_block
= block_static_block (block
);
1566 if (static_block
!= NULL
)
1567 return lookup_symbol_aux_block (name
, linkage_name
, static_block
,
1573 /* Lookup a symbol in all files' global blocks (searching psymtabs if
1577 lookup_symbol_global (const char *name
,
1578 const char *linkage_name
,
1579 const struct block
*block
,
1580 const domain_enum domain
,
1581 struct symtab
**symtab
)
1583 struct symbol
*sym
= NULL
;
1584 struct objfile
*objfile
= NULL
;
1586 /* Call library-specific lookup procedure. */
1587 objfile
= lookup_objfile_from_block (block
);
1588 if (objfile
!= NULL
)
1589 sym
= solib_global_lookup (objfile
, name
, linkage_name
, domain
, symtab
);
1593 sym
= lookup_symbol_aux_symtabs (GLOBAL_BLOCK
, name
, linkage_name
,
1598 return lookup_symbol_aux_psymtabs (GLOBAL_BLOCK
, name
, linkage_name
,
1602 /* Look, in partial_symtab PST, for symbol whose natural name is NAME.
1603 If LINKAGE_NAME is non-NULL, check in addition that the symbol's
1604 linkage name matches it. Check the global symbols if GLOBAL, the
1605 static symbols if not */
1607 struct partial_symbol
*
1608 lookup_partial_symbol (struct partial_symtab
*pst
, const char *name
,
1609 const char *linkage_name
, int global
,
1612 struct partial_symbol
*temp
;
1613 struct partial_symbol
**start
, **psym
;
1614 struct partial_symbol
**top
, **real_top
, **bottom
, **center
;
1615 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
1616 int do_linear_search
= 1;
1623 pst
->objfile
->global_psymbols
.list
+ pst
->globals_offset
:
1624 pst
->objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1626 if (global
) /* This means we can use a binary search. */
1628 do_linear_search
= 0;
1630 /* Binary search. This search is guaranteed to end with center
1631 pointing at the earliest partial symbol whose name might be
1632 correct. At that point *all* partial symbols with an
1633 appropriate name will be checked against the correct
1637 top
= start
+ length
- 1;
1639 while (top
> bottom
)
1641 center
= bottom
+ (top
- bottom
) / 2;
1642 if (!(center
< top
))
1643 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
1644 if (!do_linear_search
1645 && (SYMBOL_LANGUAGE (*center
) == language_java
))
1647 do_linear_search
= 1;
1649 if (strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*center
), name
) >= 0)
1655 bottom
= center
+ 1;
1658 if (!(top
== bottom
))
1659 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
1661 while (top
<= real_top
1662 && (linkage_name
!= NULL
1663 ? strcmp (SYMBOL_LINKAGE_NAME (*top
), linkage_name
) == 0
1664 : SYMBOL_MATCHES_SEARCH_NAME (*top
,name
)))
1666 if (SYMBOL_DOMAIN (*top
) == domain
)
1674 /* Can't use a binary search or else we found during the binary search that
1675 we should also do a linear search. */
1677 if (do_linear_search
)
1679 for (psym
= start
; psym
< start
+ length
; psym
++)
1681 if (domain
== SYMBOL_DOMAIN (*psym
))
1683 if (linkage_name
!= NULL
1684 ? strcmp (SYMBOL_LINKAGE_NAME (*psym
), linkage_name
) == 0
1685 : SYMBOL_MATCHES_SEARCH_NAME (*psym
, name
))
1696 /* Look up a type named NAME in the struct_domain. The type returned
1697 must not be opaque -- i.e., must have at least one field
1701 lookup_transparent_type (const char *name
)
1703 return current_language
->la_lookup_transparent_type (name
);
1706 /* The standard implementation of lookup_transparent_type. This code
1707 was modeled on lookup_symbol -- the parts not relevant to looking
1708 up types were just left out. In particular it's assumed here that
1709 types are available in struct_domain and only at file-static or
1713 basic_lookup_transparent_type (const char *name
)
1716 struct symtab
*s
= NULL
;
1717 struct partial_symtab
*ps
;
1718 struct blockvector
*bv
;
1719 struct objfile
*objfile
;
1720 struct block
*block
;
1722 /* Now search all the global symbols. Do the symtab's first, then
1723 check the psymtab's. If a psymtab indicates the existence
1724 of the desired name as a global, then do psymtab-to-symtab
1725 conversion on the fly and return the found symbol. */
1727 ALL_PRIMARY_SYMTABS (objfile
, s
)
1729 bv
= BLOCKVECTOR (s
);
1730 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1731 sym
= lookup_block_symbol (block
, name
, NULL
, STRUCT_DOMAIN
);
1732 if (sym
&& !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1734 return SYMBOL_TYPE (sym
);
1738 ALL_PSYMTABS (objfile
, ps
)
1740 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, NULL
,
1743 s
= PSYMTAB_TO_SYMTAB (ps
);
1744 bv
= BLOCKVECTOR (s
);
1745 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1746 sym
= lookup_block_symbol (block
, name
, NULL
, STRUCT_DOMAIN
);
1749 /* This shouldn't be necessary, but as a last resort
1750 * try looking in the statics even though the psymtab
1751 * claimed the symbol was global. It's possible that
1752 * the psymtab gets it wrong in some cases.
1754 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1755 sym
= lookup_block_symbol (block
, name
, NULL
, STRUCT_DOMAIN
);
1757 error (_("Internal: global symbol `%s' found in %s psymtab but not in symtab.\n\
1758 %s may be an inlined function, or may be a template function\n\
1759 (if a template, try specifying an instantiation: %s<type>)."),
1760 name
, ps
->filename
, name
, name
);
1762 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1763 return SYMBOL_TYPE (sym
);
1767 /* Now search the static file-level symbols.
1768 Not strictly correct, but more useful than an error.
1769 Do the symtab's first, then
1770 check the psymtab's. If a psymtab indicates the existence
1771 of the desired name as a file-level static, then do psymtab-to-symtab
1772 conversion on the fly and return the found symbol.
1775 ALL_PRIMARY_SYMTABS (objfile
, s
)
1777 bv
= BLOCKVECTOR (s
);
1778 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1779 sym
= lookup_block_symbol (block
, name
, NULL
, STRUCT_DOMAIN
);
1780 if (sym
&& !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1782 return SYMBOL_TYPE (sym
);
1786 ALL_PSYMTABS (objfile
, ps
)
1788 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, NULL
, 0, STRUCT_DOMAIN
))
1790 s
= PSYMTAB_TO_SYMTAB (ps
);
1791 bv
= BLOCKVECTOR (s
);
1792 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1793 sym
= lookup_block_symbol (block
, name
, NULL
, STRUCT_DOMAIN
);
1796 /* This shouldn't be necessary, but as a last resort
1797 * try looking in the globals even though the psymtab
1798 * claimed the symbol was static. It's possible that
1799 * the psymtab gets it wrong in some cases.
1801 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1802 sym
= lookup_block_symbol (block
, name
, NULL
, STRUCT_DOMAIN
);
1804 error (_("Internal: static symbol `%s' found in %s psymtab but not in symtab.\n\
1805 %s may be an inlined function, or may be a template function\n\
1806 (if a template, try specifying an instantiation: %s<type>)."),
1807 name
, ps
->filename
, name
, name
);
1809 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1810 return SYMBOL_TYPE (sym
);
1813 return (struct type
*) 0;
1817 /* Find the psymtab containing main(). */
1818 /* FIXME: What about languages without main() or specially linked
1819 executables that have no main() ? */
1821 struct partial_symtab
*
1822 find_main_psymtab (void)
1824 struct partial_symtab
*pst
;
1825 struct objfile
*objfile
;
1827 ALL_PSYMTABS (objfile
, pst
)
1829 if (lookup_partial_symbol (pst
, main_name (), NULL
, 1, VAR_DOMAIN
))
1837 /* Search BLOCK for symbol NAME in DOMAIN.
1839 Note that if NAME is the demangled form of a C++ symbol, we will fail
1840 to find a match during the binary search of the non-encoded names, but
1841 for now we don't worry about the slight inefficiency of looking for
1842 a match we'll never find, since it will go pretty quick. Once the
1843 binary search terminates, we drop through and do a straight linear
1844 search on the symbols. Each symbol which is marked as being a ObjC/C++
1845 symbol (language_cplus or language_objc set) has both the encoded and
1846 non-encoded names tested for a match.
1848 If LINKAGE_NAME is non-NULL, verify that any symbol we find has this
1849 particular mangled name.
1853 lookup_block_symbol (const struct block
*block
, const char *name
,
1854 const char *linkage_name
,
1855 const domain_enum domain
)
1857 struct dict_iterator iter
;
1860 if (!BLOCK_FUNCTION (block
))
1862 for (sym
= dict_iter_name_first (BLOCK_DICT (block
), name
, &iter
);
1864 sym
= dict_iter_name_next (name
, &iter
))
1866 if (SYMBOL_DOMAIN (sym
) == domain
1867 && (linkage_name
!= NULL
1868 ? strcmp (SYMBOL_LINKAGE_NAME (sym
), linkage_name
) == 0 : 1))
1875 /* Note that parameter symbols do not always show up last in the
1876 list; this loop makes sure to take anything else other than
1877 parameter symbols first; it only uses parameter symbols as a
1878 last resort. Note that this only takes up extra computation
1881 struct symbol
*sym_found
= NULL
;
1883 for (sym
= dict_iter_name_first (BLOCK_DICT (block
), name
, &iter
);
1885 sym
= dict_iter_name_next (name
, &iter
))
1887 if (SYMBOL_DOMAIN (sym
) == domain
1888 && (linkage_name
!= NULL
1889 ? strcmp (SYMBOL_LINKAGE_NAME (sym
), linkage_name
) == 0 : 1))
1892 if (SYMBOL_CLASS (sym
) != LOC_ARG
&&
1893 SYMBOL_CLASS (sym
) != LOC_LOCAL_ARG
&&
1894 SYMBOL_CLASS (sym
) != LOC_REF_ARG
&&
1895 SYMBOL_CLASS (sym
) != LOC_REGPARM
&&
1896 SYMBOL_CLASS (sym
) != LOC_REGPARM_ADDR
&&
1897 SYMBOL_CLASS (sym
) != LOC_BASEREG_ARG
&&
1898 SYMBOL_CLASS (sym
) != LOC_COMPUTED_ARG
)
1904 return (sym_found
); /* Will be NULL if not found. */
1908 /* Find the symtab associated with PC and SECTION. Look through the
1909 psymtabs and read in another symtab if necessary. */
1912 find_pc_sect_symtab (CORE_ADDR pc
, asection
*section
)
1915 struct blockvector
*bv
;
1916 struct symtab
*s
= NULL
;
1917 struct symtab
*best_s
= NULL
;
1918 struct partial_symtab
*ps
;
1919 struct objfile
*objfile
;
1920 CORE_ADDR distance
= 0;
1921 struct minimal_symbol
*msymbol
;
1923 /* If we know that this is not a text address, return failure. This is
1924 necessary because we loop based on the block's high and low code
1925 addresses, which do not include the data ranges, and because
1926 we call find_pc_sect_psymtab which has a similar restriction based
1927 on the partial_symtab's texthigh and textlow. */
1928 msymbol
= lookup_minimal_symbol_by_pc_section (pc
, section
);
1930 && (msymbol
->type
== mst_data
1931 || msymbol
->type
== mst_bss
1932 || msymbol
->type
== mst_abs
1933 || msymbol
->type
== mst_file_data
1934 || msymbol
->type
== mst_file_bss
))
1937 /* Search all symtabs for the one whose file contains our address, and which
1938 is the smallest of all the ones containing the address. This is designed
1939 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
1940 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
1941 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
1943 This happens for native ecoff format, where code from included files
1944 gets its own symtab. The symtab for the included file should have
1945 been read in already via the dependency mechanism.
1946 It might be swifter to create several symtabs with the same name
1947 like xcoff does (I'm not sure).
1949 It also happens for objfiles that have their functions reordered.
1950 For these, the symtab we are looking for is not necessarily read in. */
1952 ALL_PRIMARY_SYMTABS (objfile
, s
)
1954 bv
= BLOCKVECTOR (s
);
1955 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1957 if (BLOCK_START (b
) <= pc
1958 && BLOCK_END (b
) > pc
1960 || BLOCK_END (b
) - BLOCK_START (b
) < distance
))
1962 /* For an objfile that has its functions reordered,
1963 find_pc_psymtab will find the proper partial symbol table
1964 and we simply return its corresponding symtab. */
1965 /* In order to better support objfiles that contain both
1966 stabs and coff debugging info, we continue on if a psymtab
1968 if ((objfile
->flags
& OBJF_REORDERED
) && objfile
->psymtabs
)
1970 ps
= find_pc_sect_psymtab (pc
, section
);
1972 return PSYMTAB_TO_SYMTAB (ps
);
1976 struct dict_iterator iter
;
1977 struct symbol
*sym
= NULL
;
1979 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1981 fixup_symbol_section (sym
, objfile
);
1982 if (matching_bfd_sections (SYMBOL_BFD_SECTION (sym
), section
))
1986 continue; /* no symbol in this symtab matches section */
1988 distance
= BLOCK_END (b
) - BLOCK_START (b
);
1997 ps
= find_pc_sect_psymtab (pc
, section
);
2001 /* Might want to error() here (in case symtab is corrupt and
2002 will cause a core dump), but maybe we can successfully
2003 continue, so let's not. */
2005 (Internal error: pc 0x%s in read in psymtab, but not in symtab.)\n"),
2007 s
= PSYMTAB_TO_SYMTAB (ps
);
2012 /* Find the symtab associated with PC. Look through the psymtabs and
2013 read in another symtab if necessary. Backward compatibility, no section */
2016 find_pc_symtab (CORE_ADDR pc
)
2018 return find_pc_sect_symtab (pc
, find_pc_mapped_section (pc
));
2022 /* Find the source file and line number for a given PC value and SECTION.
2023 Return a structure containing a symtab pointer, a line number,
2024 and a pc range for the entire source line.
2025 The value's .pc field is NOT the specified pc.
2026 NOTCURRENT nonzero means, if specified pc is on a line boundary,
2027 use the line that ends there. Otherwise, in that case, the line
2028 that begins there is used. */
2030 /* The big complication here is that a line may start in one file, and end just
2031 before the start of another file. This usually occurs when you #include
2032 code in the middle of a subroutine. To properly find the end of a line's PC
2033 range, we must search all symtabs associated with this compilation unit, and
2034 find the one whose first PC is closer than that of the next line in this
2037 /* If it's worth the effort, we could be using a binary search. */
2039 struct symtab_and_line
2040 find_pc_sect_line (CORE_ADDR pc
, struct bfd_section
*section
, int notcurrent
)
2043 struct linetable
*l
;
2046 struct linetable_entry
*item
;
2047 struct symtab_and_line val
;
2048 struct blockvector
*bv
;
2049 struct minimal_symbol
*msymbol
;
2050 struct minimal_symbol
*mfunsym
;
2052 /* Info on best line seen so far, and where it starts, and its file. */
2054 struct linetable_entry
*best
= NULL
;
2055 CORE_ADDR best_end
= 0;
2056 struct symtab
*best_symtab
= 0;
2058 /* Store here the first line number
2059 of a file which contains the line at the smallest pc after PC.
2060 If we don't find a line whose range contains PC,
2061 we will use a line one less than this,
2062 with a range from the start of that file to the first line's pc. */
2063 struct linetable_entry
*alt
= NULL
;
2064 struct symtab
*alt_symtab
= 0;
2066 /* Info on best line seen in this file. */
2068 struct linetable_entry
*prev
;
2070 /* If this pc is not from the current frame,
2071 it is the address of the end of a call instruction.
2072 Quite likely that is the start of the following statement.
2073 But what we want is the statement containing the instruction.
2074 Fudge the pc to make sure we get that. */
2076 init_sal (&val
); /* initialize to zeroes */
2078 /* It's tempting to assume that, if we can't find debugging info for
2079 any function enclosing PC, that we shouldn't search for line
2080 number info, either. However, GAS can emit line number info for
2081 assembly files --- very helpful when debugging hand-written
2082 assembly code. In such a case, we'd have no debug info for the
2083 function, but we would have line info. */
2088 /* elz: added this because this function returned the wrong
2089 information if the pc belongs to a stub (import/export)
2090 to call a shlib function. This stub would be anywhere between
2091 two functions in the target, and the line info was erroneously
2092 taken to be the one of the line before the pc.
2094 /* RT: Further explanation:
2096 * We have stubs (trampolines) inserted between procedures.
2098 * Example: "shr1" exists in a shared library, and a "shr1" stub also
2099 * exists in the main image.
2101 * In the minimal symbol table, we have a bunch of symbols
2102 * sorted by start address. The stubs are marked as "trampoline",
2103 * the others appear as text. E.g.:
2105 * Minimal symbol table for main image
2106 * main: code for main (text symbol)
2107 * shr1: stub (trampoline symbol)
2108 * foo: code for foo (text symbol)
2110 * Minimal symbol table for "shr1" image:
2112 * shr1: code for shr1 (text symbol)
2115 * So the code below is trying to detect if we are in the stub
2116 * ("shr1" stub), and if so, find the real code ("shr1" trampoline),
2117 * and if found, do the symbolization from the real-code address
2118 * rather than the stub address.
2120 * Assumptions being made about the minimal symbol table:
2121 * 1. lookup_minimal_symbol_by_pc() will return a trampoline only
2122 * if we're really in the trampoline. If we're beyond it (say
2123 * we're in "foo" in the above example), it'll have a closer
2124 * symbol (the "foo" text symbol for example) and will not
2125 * return the trampoline.
2126 * 2. lookup_minimal_symbol_text() will find a real text symbol
2127 * corresponding to the trampoline, and whose address will
2128 * be different than the trampoline address. I put in a sanity
2129 * check for the address being the same, to avoid an
2130 * infinite recursion.
2132 msymbol
= lookup_minimal_symbol_by_pc (pc
);
2133 if (msymbol
!= NULL
)
2134 if (MSYMBOL_TYPE (msymbol
) == mst_solib_trampoline
)
2136 mfunsym
= lookup_minimal_symbol_text (SYMBOL_LINKAGE_NAME (msymbol
),
2138 if (mfunsym
== NULL
)
2139 /* I eliminated this warning since it is coming out
2140 * in the following situation:
2141 * gdb shmain // test program with shared libraries
2142 * (gdb) break shr1 // function in shared lib
2143 * Warning: In stub for ...
2144 * In the above situation, the shared lib is not loaded yet,
2145 * so of course we can't find the real func/line info,
2146 * but the "break" still works, and the warning is annoying.
2147 * So I commented out the warning. RT */
2148 /* warning ("In stub for %s; unable to find real function/line info", SYMBOL_LINKAGE_NAME (msymbol)) */ ;
2150 else if (SYMBOL_VALUE_ADDRESS (mfunsym
) == SYMBOL_VALUE_ADDRESS (msymbol
))
2151 /* Avoid infinite recursion */
2152 /* See above comment about why warning is commented out */
2153 /* warning ("In stub for %s; unable to find real function/line info", SYMBOL_LINKAGE_NAME (msymbol)) */ ;
2156 return find_pc_line (SYMBOL_VALUE_ADDRESS (mfunsym
), 0);
2160 s
= find_pc_sect_symtab (pc
, section
);
2163 /* if no symbol information, return previous pc */
2170 bv
= BLOCKVECTOR (s
);
2172 /* Look at all the symtabs that share this blockvector.
2173 They all have the same apriori range, that we found was right;
2174 but they have different line tables. */
2176 for (; s
&& BLOCKVECTOR (s
) == bv
; s
= s
->next
)
2178 /* Find the best line in this symtab. */
2185 /* I think len can be zero if the symtab lacks line numbers
2186 (e.g. gcc -g1). (Either that or the LINETABLE is NULL;
2187 I'm not sure which, and maybe it depends on the symbol
2193 item
= l
->item
; /* Get first line info */
2195 /* Is this file's first line closer than the first lines of other files?
2196 If so, record this file, and its first line, as best alternate. */
2197 if (item
->pc
> pc
&& (!alt
|| item
->pc
< alt
->pc
))
2203 for (i
= 0; i
< len
; i
++, item
++)
2205 /* Leave prev pointing to the linetable entry for the last line
2206 that started at or before PC. */
2213 /* At this point, prev points at the line whose start addr is <= pc, and
2214 item points at the next line. If we ran off the end of the linetable
2215 (pc >= start of the last line), then prev == item. If pc < start of
2216 the first line, prev will not be set. */
2218 /* Is this file's best line closer than the best in the other files?
2219 If so, record this file, and its best line, as best so far. Don't
2220 save prev if it represents the end of a function (i.e. line number
2221 0) instead of a real line. */
2223 if (prev
&& prev
->line
&& (!best
|| prev
->pc
> best
->pc
))
2228 /* Discard BEST_END if it's before the PC of the current BEST. */
2229 if (best_end
<= best
->pc
)
2233 /* If another line (denoted by ITEM) is in the linetable and its
2234 PC is after BEST's PC, but before the current BEST_END, then
2235 use ITEM's PC as the new best_end. */
2236 if (best
&& i
< len
&& item
->pc
> best
->pc
2237 && (best_end
== 0 || best_end
> item
->pc
))
2238 best_end
= item
->pc
;
2243 /* If we didn't find any line number info, just return zeros.
2244 We used to return alt->line - 1 here, but that could be
2245 anywhere; if we don't have line number info for this PC,
2246 don't make some up. */
2249 else if (best
->line
== 0)
2251 /* If our best fit is in a range of PC's for which no line
2252 number info is available (line number is zero) then we didn't
2253 find any valid line information. */
2258 val
.symtab
= best_symtab
;
2259 val
.line
= best
->line
;
2261 if (best_end
&& (!alt
|| best_end
< alt
->pc
))
2266 val
.end
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
2268 val
.section
= section
;
2272 /* Backward compatibility (no section) */
2274 struct symtab_and_line
2275 find_pc_line (CORE_ADDR pc
, int notcurrent
)
2279 section
= find_pc_overlay (pc
);
2280 if (pc_in_unmapped_range (pc
, section
))
2281 pc
= overlay_mapped_address (pc
, section
);
2282 return find_pc_sect_line (pc
, section
, notcurrent
);
2285 /* Find line number LINE in any symtab whose name is the same as
2288 If found, return the symtab that contains the linetable in which it was
2289 found, set *INDEX to the index in the linetable of the best entry
2290 found, and set *EXACT_MATCH nonzero if the value returned is an
2293 If not found, return NULL. */
2296 find_line_symtab (struct symtab
*symtab
, int line
, int *index
, int *exact_match
)
2300 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
2304 struct linetable
*best_linetable
;
2305 struct symtab
*best_symtab
;
2307 /* First try looking it up in the given symtab. */
2308 best_linetable
= LINETABLE (symtab
);
2309 best_symtab
= symtab
;
2310 best_index
= find_line_common (best_linetable
, line
, &exact
);
2311 if (best_index
< 0 || !exact
)
2313 /* Didn't find an exact match. So we better keep looking for
2314 another symtab with the same name. In the case of xcoff,
2315 multiple csects for one source file (produced by IBM's FORTRAN
2316 compiler) produce multiple symtabs (this is unavoidable
2317 assuming csects can be at arbitrary places in memory and that
2318 the GLOBAL_BLOCK of a symtab has a begin and end address). */
2320 /* BEST is the smallest linenumber > LINE so far seen,
2321 or 0 if none has been seen so far.
2322 BEST_INDEX and BEST_LINETABLE identify the item for it. */
2325 struct objfile
*objfile
;
2327 struct partial_symtab
*p
;
2329 if (best_index
>= 0)
2330 best
= best_linetable
->item
[best_index
].line
;
2334 ALL_PSYMTABS (objfile
, p
)
2336 if (strcmp (symtab
->filename
, p
->filename
) != 0)
2338 PSYMTAB_TO_SYMTAB (p
);
2341 ALL_SYMTABS (objfile
, s
)
2343 struct linetable
*l
;
2346 if (strcmp (symtab
->filename
, s
->filename
) != 0)
2349 ind
= find_line_common (l
, line
, &exact
);
2359 if (best
== 0 || l
->item
[ind
].line
< best
)
2361 best
= l
->item
[ind
].line
;
2374 *index
= best_index
;
2376 *exact_match
= exact
;
2381 /* Set the PC value for a given source file and line number and return true.
2382 Returns zero for invalid line number (and sets the PC to 0).
2383 The source file is specified with a struct symtab. */
2386 find_line_pc (struct symtab
*symtab
, int line
, CORE_ADDR
*pc
)
2388 struct linetable
*l
;
2395 symtab
= find_line_symtab (symtab
, line
, &ind
, NULL
);
2398 l
= LINETABLE (symtab
);
2399 *pc
= l
->item
[ind
].pc
;
2406 /* Find the range of pc values in a line.
2407 Store the starting pc of the line into *STARTPTR
2408 and the ending pc (start of next line) into *ENDPTR.
2409 Returns 1 to indicate success.
2410 Returns 0 if could not find the specified line. */
2413 find_line_pc_range (struct symtab_and_line sal
, CORE_ADDR
*startptr
,
2416 CORE_ADDR startaddr
;
2417 struct symtab_and_line found_sal
;
2420 if (startaddr
== 0 && !find_line_pc (sal
.symtab
, sal
.line
, &startaddr
))
2423 /* This whole function is based on address. For example, if line 10 has
2424 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
2425 "info line *0x123" should say the line goes from 0x100 to 0x200
2426 and "info line *0x355" should say the line goes from 0x300 to 0x400.
2427 This also insures that we never give a range like "starts at 0x134
2428 and ends at 0x12c". */
2430 found_sal
= find_pc_sect_line (startaddr
, sal
.section
, 0);
2431 if (found_sal
.line
!= sal
.line
)
2433 /* The specified line (sal) has zero bytes. */
2434 *startptr
= found_sal
.pc
;
2435 *endptr
= found_sal
.pc
;
2439 *startptr
= found_sal
.pc
;
2440 *endptr
= found_sal
.end
;
2445 /* Given a line table and a line number, return the index into the line
2446 table for the pc of the nearest line whose number is >= the specified one.
2447 Return -1 if none is found. The value is >= 0 if it is an index.
2449 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
2452 find_line_common (struct linetable
*l
, int lineno
,
2458 /* BEST is the smallest linenumber > LINENO so far seen,
2459 or 0 if none has been seen so far.
2460 BEST_INDEX identifies the item for it. */
2462 int best_index
= -1;
2473 for (i
= 0; i
< len
; i
++)
2475 struct linetable_entry
*item
= &(l
->item
[i
]);
2477 if (item
->line
== lineno
)
2479 /* Return the first (lowest address) entry which matches. */
2484 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
2491 /* If we got here, we didn't get an exact match. */
2496 find_pc_line_pc_range (CORE_ADDR pc
, CORE_ADDR
*startptr
, CORE_ADDR
*endptr
)
2498 struct symtab_and_line sal
;
2499 sal
= find_pc_line (pc
, 0);
2502 return sal
.symtab
!= 0;
2505 /* Given a function start address PC and SECTION, find the first
2506 address after the function prologue. */
2508 find_function_start_pc (struct gdbarch
*gdbarch
,
2509 CORE_ADDR pc
, asection
*section
)
2511 /* If the function is in an unmapped overlay, use its unmapped LMA address,
2512 so that gdbarch_skip_prologue has something unique to work on. */
2513 if (section_is_overlay (section
) && !section_is_mapped (section
))
2514 pc
= overlay_unmapped_address (pc
, section
);
2516 pc
+= gdbarch_deprecated_function_start_offset (gdbarch
);
2517 pc
= gdbarch_skip_prologue (gdbarch
, pc
);
2519 /* For overlays, map pc back into its mapped VMA range. */
2520 pc
= overlay_mapped_address (pc
, section
);
2525 /* Given a function symbol SYM, find the symtab and line for the start
2527 If the argument FUNFIRSTLINE is nonzero, we want the first line
2528 of real code inside the function. */
2530 struct symtab_and_line
2531 find_function_start_sal (struct symbol
*sym
, int funfirstline
)
2533 struct block
*block
= SYMBOL_BLOCK_VALUE (sym
);
2534 struct objfile
*objfile
= lookup_objfile_from_block (block
);
2535 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2538 struct symtab_and_line sal
;
2540 pc
= BLOCK_START (block
);
2541 fixup_symbol_section (sym
, objfile
);
2544 /* Skip "first line" of function (which is actually its prologue). */
2545 pc
= find_function_start_pc (gdbarch
, pc
, SYMBOL_BFD_SECTION (sym
));
2547 sal
= find_pc_sect_line (pc
, SYMBOL_BFD_SECTION (sym
), 0);
2549 /* Check if gdbarch_skip_prologue left us in mid-line, and the next
2550 line is still part of the same function. */
2552 && BLOCK_START (block
) <= sal
.end
2553 && sal
.end
< BLOCK_END (block
))
2555 /* First pc of next line */
2557 /* Recalculate the line number (might not be N+1). */
2558 sal
= find_pc_sect_line (pc
, SYMBOL_BFD_SECTION (sym
), 0);
2565 /* If P is of the form "operator[ \t]+..." where `...' is
2566 some legitimate operator text, return a pointer to the
2567 beginning of the substring of the operator text.
2568 Otherwise, return "". */
2570 operator_chars (char *p
, char **end
)
2573 if (strncmp (p
, "operator", 8))
2577 /* Don't get faked out by `operator' being part of a longer
2579 if (isalpha (*p
) || *p
== '_' || *p
== '$' || *p
== '\0')
2582 /* Allow some whitespace between `operator' and the operator symbol. */
2583 while (*p
== ' ' || *p
== '\t')
2586 /* Recognize 'operator TYPENAME'. */
2588 if (isalpha (*p
) || *p
== '_' || *p
== '$')
2591 while (isalnum (*q
) || *q
== '_' || *q
== '$')
2600 case '\\': /* regexp quoting */
2603 if (p
[2] == '=') /* 'operator\*=' */
2605 else /* 'operator\*' */
2609 else if (p
[1] == '[')
2612 error (_("mismatched quoting on brackets, try 'operator\\[\\]'"));
2613 else if (p
[2] == '\\' && p
[3] == ']')
2615 *end
= p
+ 4; /* 'operator\[\]' */
2619 error (_("nothing is allowed between '[' and ']'"));
2623 /* Gratuitous qoute: skip it and move on. */
2645 if (p
[0] == '-' && p
[1] == '>')
2647 /* Struct pointer member operator 'operator->'. */
2650 *end
= p
+ 3; /* 'operator->*' */
2653 else if (p
[2] == '\\')
2655 *end
= p
+ 4; /* Hopefully 'operator->\*' */
2660 *end
= p
+ 2; /* 'operator->' */
2664 if (p
[1] == '=' || p
[1] == p
[0])
2675 error (_("`operator ()' must be specified without whitespace in `()'"));
2680 error (_("`operator ?:' must be specified without whitespace in `?:'"));
2685 error (_("`operator []' must be specified without whitespace in `[]'"));
2689 error (_("`operator %s' not supported"), p
);
2698 /* If FILE is not already in the table of files, return zero;
2699 otherwise return non-zero. Optionally add FILE to the table if ADD
2700 is non-zero. If *FIRST is non-zero, forget the old table
2703 filename_seen (const char *file
, int add
, int *first
)
2705 /* Table of files seen so far. */
2706 static const char **tab
= NULL
;
2707 /* Allocated size of tab in elements.
2708 Start with one 256-byte block (when using GNU malloc.c).
2709 24 is the malloc overhead when range checking is in effect. */
2710 static int tab_alloc_size
= (256 - 24) / sizeof (char *);
2711 /* Current size of tab in elements. */
2712 static int tab_cur_size
;
2718 tab
= (const char **) xmalloc (tab_alloc_size
* sizeof (*tab
));
2722 /* Is FILE in tab? */
2723 for (p
= tab
; p
< tab
+ tab_cur_size
; p
++)
2724 if (strcmp (*p
, file
) == 0)
2727 /* No; maybe add it to tab. */
2730 if (tab_cur_size
== tab_alloc_size
)
2732 tab_alloc_size
*= 2;
2733 tab
= (const char **) xrealloc ((char *) tab
,
2734 tab_alloc_size
* sizeof (*tab
));
2736 tab
[tab_cur_size
++] = file
;
2742 /* Slave routine for sources_info. Force line breaks at ,'s.
2743 NAME is the name to print and *FIRST is nonzero if this is the first
2744 name printed. Set *FIRST to zero. */
2746 output_source_filename (const char *name
, int *first
)
2748 /* Since a single source file can result in several partial symbol
2749 tables, we need to avoid printing it more than once. Note: if
2750 some of the psymtabs are read in and some are not, it gets
2751 printed both under "Source files for which symbols have been
2752 read" and "Source files for which symbols will be read in on
2753 demand". I consider this a reasonable way to deal with the
2754 situation. I'm not sure whether this can also happen for
2755 symtabs; it doesn't hurt to check. */
2757 /* Was NAME already seen? */
2758 if (filename_seen (name
, 1, first
))
2760 /* Yes; don't print it again. */
2763 /* No; print it and reset *FIRST. */
2770 printf_filtered (", ");
2774 fputs_filtered (name
, gdb_stdout
);
2778 sources_info (char *ignore
, int from_tty
)
2781 struct partial_symtab
*ps
;
2782 struct objfile
*objfile
;
2785 if (!have_full_symbols () && !have_partial_symbols ())
2787 error (_("No symbol table is loaded. Use the \"file\" command."));
2790 printf_filtered ("Source files for which symbols have been read in:\n\n");
2793 ALL_SYMTABS (objfile
, s
)
2795 const char *fullname
= symtab_to_fullname (s
);
2796 output_source_filename (fullname
? fullname
: s
->filename
, &first
);
2798 printf_filtered ("\n\n");
2800 printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
2803 ALL_PSYMTABS (objfile
, ps
)
2807 const char *fullname
= psymtab_to_fullname (ps
);
2808 output_source_filename (fullname
? fullname
: ps
->filename
, &first
);
2811 printf_filtered ("\n");
2815 file_matches (char *file
, char *files
[], int nfiles
)
2819 if (file
!= NULL
&& nfiles
!= 0)
2821 for (i
= 0; i
< nfiles
; i
++)
2823 if (strcmp (files
[i
], lbasename (file
)) == 0)
2827 else if (nfiles
== 0)
2832 /* Free any memory associated with a search. */
2834 free_search_symbols (struct symbol_search
*symbols
)
2836 struct symbol_search
*p
;
2837 struct symbol_search
*next
;
2839 for (p
= symbols
; p
!= NULL
; p
= next
)
2847 do_free_search_symbols_cleanup (void *symbols
)
2849 free_search_symbols (symbols
);
2853 make_cleanup_free_search_symbols (struct symbol_search
*symbols
)
2855 return make_cleanup (do_free_search_symbols_cleanup
, symbols
);
2858 /* Helper function for sort_search_symbols and qsort. Can only
2859 sort symbols, not minimal symbols. */
2861 compare_search_syms (const void *sa
, const void *sb
)
2863 struct symbol_search
**sym_a
= (struct symbol_search
**) sa
;
2864 struct symbol_search
**sym_b
= (struct symbol_search
**) sb
;
2866 return strcmp (SYMBOL_PRINT_NAME ((*sym_a
)->symbol
),
2867 SYMBOL_PRINT_NAME ((*sym_b
)->symbol
));
2870 /* Sort the ``nfound'' symbols in the list after prevtail. Leave
2871 prevtail where it is, but update its next pointer to point to
2872 the first of the sorted symbols. */
2873 static struct symbol_search
*
2874 sort_search_symbols (struct symbol_search
*prevtail
, int nfound
)
2876 struct symbol_search
**symbols
, *symp
, *old_next
;
2879 symbols
= (struct symbol_search
**) xmalloc (sizeof (struct symbol_search
*)
2881 symp
= prevtail
->next
;
2882 for (i
= 0; i
< nfound
; i
++)
2887 /* Generally NULL. */
2890 qsort (symbols
, nfound
, sizeof (struct symbol_search
*),
2891 compare_search_syms
);
2894 for (i
= 0; i
< nfound
; i
++)
2896 symp
->next
= symbols
[i
];
2899 symp
->next
= old_next
;
2905 /* Search the symbol table for matches to the regular expression REGEXP,
2906 returning the results in *MATCHES.
2908 Only symbols of KIND are searched:
2909 FUNCTIONS_DOMAIN - search all functions
2910 TYPES_DOMAIN - search all type names
2911 METHODS_DOMAIN - search all methods NOT IMPLEMENTED
2912 VARIABLES_DOMAIN - search all symbols, excluding functions, type names,
2913 and constants (enums)
2915 free_search_symbols should be called when *MATCHES is no longer needed.
2917 The results are sorted locally; each symtab's global and static blocks are
2918 separately alphabetized.
2921 search_symbols (char *regexp
, domain_enum kind
, int nfiles
, char *files
[],
2922 struct symbol_search
**matches
)
2925 struct partial_symtab
*ps
;
2926 struct blockvector
*bv
;
2929 struct dict_iterator iter
;
2931 struct partial_symbol
**psym
;
2932 struct objfile
*objfile
;
2933 struct minimal_symbol
*msymbol
;
2936 static enum minimal_symbol_type types
[]
2938 {mst_data
, mst_text
, mst_abs
, mst_unknown
};
2939 static enum minimal_symbol_type types2
[]
2941 {mst_bss
, mst_file_text
, mst_abs
, mst_unknown
};
2942 static enum minimal_symbol_type types3
[]
2944 {mst_file_data
, mst_solib_trampoline
, mst_abs
, mst_unknown
};
2945 static enum minimal_symbol_type types4
[]
2947 {mst_file_bss
, mst_text
, mst_abs
, mst_unknown
};
2948 enum minimal_symbol_type ourtype
;
2949 enum minimal_symbol_type ourtype2
;
2950 enum minimal_symbol_type ourtype3
;
2951 enum minimal_symbol_type ourtype4
;
2952 struct symbol_search
*sr
;
2953 struct symbol_search
*psr
;
2954 struct symbol_search
*tail
;
2955 struct cleanup
*old_chain
= NULL
;
2957 if (kind
< VARIABLES_DOMAIN
)
2958 error (_("must search on specific domain"));
2960 ourtype
= types
[(int) (kind
- VARIABLES_DOMAIN
)];
2961 ourtype2
= types2
[(int) (kind
- VARIABLES_DOMAIN
)];
2962 ourtype3
= types3
[(int) (kind
- VARIABLES_DOMAIN
)];
2963 ourtype4
= types4
[(int) (kind
- VARIABLES_DOMAIN
)];
2965 sr
= *matches
= NULL
;
2970 /* Make sure spacing is right for C++ operators.
2971 This is just a courtesy to make the matching less sensitive
2972 to how many spaces the user leaves between 'operator'
2973 and <TYPENAME> or <OPERATOR>. */
2975 char *opname
= operator_chars (regexp
, &opend
);
2978 int fix
= -1; /* -1 means ok; otherwise number of spaces needed. */
2979 if (isalpha (*opname
) || *opname
== '_' || *opname
== '$')
2981 /* There should 1 space between 'operator' and 'TYPENAME'. */
2982 if (opname
[-1] != ' ' || opname
[-2] == ' ')
2987 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
2988 if (opname
[-1] == ' ')
2991 /* If wrong number of spaces, fix it. */
2994 char *tmp
= (char *) alloca (8 + fix
+ strlen (opname
) + 1);
2995 sprintf (tmp
, "operator%.*s%s", fix
, " ", opname
);
3000 if (0 != (val
= re_comp (regexp
)))
3001 error (_("Invalid regexp (%s): %s"), val
, regexp
);
3004 /* Search through the partial symtabs *first* for all symbols
3005 matching the regexp. That way we don't have to reproduce all of
3006 the machinery below. */
3008 ALL_PSYMTABS (objfile
, ps
)
3010 struct partial_symbol
**bound
, **gbound
, **sbound
;
3016 gbound
= objfile
->global_psymbols
.list
+ ps
->globals_offset
+ ps
->n_global_syms
;
3017 sbound
= objfile
->static_psymbols
.list
+ ps
->statics_offset
+ ps
->n_static_syms
;
3020 /* Go through all of the symbols stored in a partial
3021 symtab in one loop. */
3022 psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
3027 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
3029 psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
3040 /* If it would match (logic taken from loop below)
3041 load the file and go on to the next one. We check the
3042 filename here, but that's a bit bogus: we don't know
3043 what file it really comes from until we have full
3044 symtabs. The symbol might be in a header file included by
3045 this psymtab. This only affects Insight. */
3046 if (file_matches (ps
->filename
, files
, nfiles
)
3048 || re_exec (SYMBOL_NATURAL_NAME (*psym
)) != 0)
3049 && ((kind
== VARIABLES_DOMAIN
&& SYMBOL_CLASS (*psym
) != LOC_TYPEDEF
3050 && SYMBOL_CLASS (*psym
) != LOC_BLOCK
)
3051 || (kind
== FUNCTIONS_DOMAIN
&& SYMBOL_CLASS (*psym
) == LOC_BLOCK
)
3052 || (kind
== TYPES_DOMAIN
&& SYMBOL_CLASS (*psym
) == LOC_TYPEDEF
)
3053 || (kind
== METHODS_DOMAIN
&& SYMBOL_CLASS (*psym
) == LOC_BLOCK
))))
3055 PSYMTAB_TO_SYMTAB (ps
);
3063 /* Here, we search through the minimal symbol tables for functions
3064 and variables that match, and force their symbols to be read.
3065 This is in particular necessary for demangled variable names,
3066 which are no longer put into the partial symbol tables.
3067 The symbol will then be found during the scan of symtabs below.
3069 For functions, find_pc_symtab should succeed if we have debug info
3070 for the function, for variables we have to call lookup_symbol
3071 to determine if the variable has debug info.
3072 If the lookup fails, set found_misc so that we will rescan to print
3073 any matching symbols without debug info.
3076 if (nfiles
== 0 && (kind
== VARIABLES_DOMAIN
|| kind
== FUNCTIONS_DOMAIN
))
3078 ALL_MSYMBOLS (objfile
, msymbol
)
3080 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
3081 MSYMBOL_TYPE (msymbol
) == ourtype2
||
3082 MSYMBOL_TYPE (msymbol
) == ourtype3
||
3083 MSYMBOL_TYPE (msymbol
) == ourtype4
)
3086 || re_exec (SYMBOL_NATURAL_NAME (msymbol
)) != 0)
3088 if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
)))
3090 /* FIXME: carlton/2003-02-04: Given that the
3091 semantics of lookup_symbol keeps on changing
3092 slightly, it would be a nice idea if we had a
3093 function lookup_symbol_minsym that found the
3094 symbol associated to a given minimal symbol (if
3096 if (kind
== FUNCTIONS_DOMAIN
3097 || lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol
),
3098 (struct block
*) NULL
,
3100 0, (struct symtab
**) NULL
)
3109 ALL_PRIMARY_SYMTABS (objfile
, s
)
3111 bv
= BLOCKVECTOR (s
);
3112 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
3114 struct symbol_search
*prevtail
= tail
;
3116 b
= BLOCKVECTOR_BLOCK (bv
, i
);
3117 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
3119 struct symtab
*real_symtab
= SYMBOL_SYMTAB (sym
);
3122 if (file_matches (real_symtab
->filename
, files
, nfiles
)
3124 || re_exec (SYMBOL_NATURAL_NAME (sym
)) != 0)
3125 && ((kind
== VARIABLES_DOMAIN
&& SYMBOL_CLASS (sym
) != LOC_TYPEDEF
3126 && SYMBOL_CLASS (sym
) != LOC_BLOCK
3127 && SYMBOL_CLASS (sym
) != LOC_CONST
)
3128 || (kind
== FUNCTIONS_DOMAIN
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
3129 || (kind
== TYPES_DOMAIN
&& SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
3130 || (kind
== METHODS_DOMAIN
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
))))
3133 psr
= (struct symbol_search
*) xmalloc (sizeof (struct symbol_search
));
3135 psr
->symtab
= real_symtab
;
3137 psr
->msymbol
= NULL
;
3149 if (prevtail
== NULL
)
3151 struct symbol_search dummy
;
3154 tail
= sort_search_symbols (&dummy
, nfound
);
3157 old_chain
= make_cleanup_free_search_symbols (sr
);
3160 tail
= sort_search_symbols (prevtail
, nfound
);
3165 /* If there are no eyes, avoid all contact. I mean, if there are
3166 no debug symbols, then print directly from the msymbol_vector. */
3168 if (found_misc
|| kind
!= FUNCTIONS_DOMAIN
)
3170 ALL_MSYMBOLS (objfile
, msymbol
)
3172 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
3173 MSYMBOL_TYPE (msymbol
) == ourtype2
||
3174 MSYMBOL_TYPE (msymbol
) == ourtype3
||
3175 MSYMBOL_TYPE (msymbol
) == ourtype4
)
3178 || re_exec (SYMBOL_NATURAL_NAME (msymbol
)) != 0)
3180 /* Functions: Look up by address. */
3181 if (kind
!= FUNCTIONS_DOMAIN
||
3182 (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
))))
3184 /* Variables/Absolutes: Look up by name */
3185 if (lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol
),
3186 (struct block
*) NULL
, VAR_DOMAIN
,
3187 0, (struct symtab
**) NULL
) == NULL
)
3190 psr
= (struct symbol_search
*) xmalloc (sizeof (struct symbol_search
));
3192 psr
->msymbol
= msymbol
;
3199 old_chain
= make_cleanup_free_search_symbols (sr
);
3213 discard_cleanups (old_chain
);
3216 /* Helper function for symtab_symbol_info, this function uses
3217 the data returned from search_symbols() to print information
3218 regarding the match to gdb_stdout.
3221 print_symbol_info (domain_enum kind
, struct symtab
*s
, struct symbol
*sym
,
3222 int block
, char *last
)
3224 if (last
== NULL
|| strcmp (last
, s
->filename
) != 0)
3226 fputs_filtered ("\nFile ", gdb_stdout
);
3227 fputs_filtered (s
->filename
, gdb_stdout
);
3228 fputs_filtered (":\n", gdb_stdout
);
3231 if (kind
!= TYPES_DOMAIN
&& block
== STATIC_BLOCK
)
3232 printf_filtered ("static ");
3234 /* Typedef that is not a C++ class */
3235 if (kind
== TYPES_DOMAIN
3236 && SYMBOL_DOMAIN (sym
) != STRUCT_DOMAIN
)
3237 typedef_print (SYMBOL_TYPE (sym
), sym
, gdb_stdout
);
3238 /* variable, func, or typedef-that-is-c++-class */
3239 else if (kind
< TYPES_DOMAIN
||
3240 (kind
== TYPES_DOMAIN
&&
3241 SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
))
3243 type_print (SYMBOL_TYPE (sym
),
3244 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
3245 ? "" : SYMBOL_PRINT_NAME (sym
)),
3248 printf_filtered (";\n");
3252 /* This help function for symtab_symbol_info() prints information
3253 for non-debugging symbols to gdb_stdout.
3256 print_msymbol_info (struct minimal_symbol
*msymbol
)
3260 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
3261 tmp
= hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol
)
3262 & (CORE_ADDR
) 0xffffffff,
3265 tmp
= hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol
),
3267 printf_filtered ("%s %s\n",
3268 tmp
, SYMBOL_PRINT_NAME (msymbol
));
3271 /* This is the guts of the commands "info functions", "info types", and
3272 "info variables". It calls search_symbols to find all matches and then
3273 print_[m]symbol_info to print out some useful information about the
3277 symtab_symbol_info (char *regexp
, domain_enum kind
, int from_tty
)
3279 static char *classnames
[]
3281 {"variable", "function", "type", "method"};
3282 struct symbol_search
*symbols
;
3283 struct symbol_search
*p
;
3284 struct cleanup
*old_chain
;
3285 char *last_filename
= NULL
;
3288 /* must make sure that if we're interrupted, symbols gets freed */
3289 search_symbols (regexp
, kind
, 0, (char **) NULL
, &symbols
);
3290 old_chain
= make_cleanup_free_search_symbols (symbols
);
3292 printf_filtered (regexp
3293 ? "All %ss matching regular expression \"%s\":\n"
3294 : "All defined %ss:\n",
3295 classnames
[(int) (kind
- VARIABLES_DOMAIN
)], regexp
);
3297 for (p
= symbols
; p
!= NULL
; p
= p
->next
)
3301 if (p
->msymbol
!= NULL
)
3305 printf_filtered ("\nNon-debugging symbols:\n");
3308 print_msymbol_info (p
->msymbol
);
3312 print_symbol_info (kind
,
3317 last_filename
= p
->symtab
->filename
;
3321 do_cleanups (old_chain
);
3325 variables_info (char *regexp
, int from_tty
)
3327 symtab_symbol_info (regexp
, VARIABLES_DOMAIN
, from_tty
);
3331 functions_info (char *regexp
, int from_tty
)
3333 symtab_symbol_info (regexp
, FUNCTIONS_DOMAIN
, from_tty
);
3338 types_info (char *regexp
, int from_tty
)
3340 symtab_symbol_info (regexp
, TYPES_DOMAIN
, from_tty
);
3343 /* Breakpoint all functions matching regular expression. */
3346 rbreak_command_wrapper (char *regexp
, int from_tty
)
3348 rbreak_command (regexp
, from_tty
);
3352 rbreak_command (char *regexp
, int from_tty
)
3354 struct symbol_search
*ss
;
3355 struct symbol_search
*p
;
3356 struct cleanup
*old_chain
;
3358 search_symbols (regexp
, FUNCTIONS_DOMAIN
, 0, (char **) NULL
, &ss
);
3359 old_chain
= make_cleanup_free_search_symbols (ss
);
3361 for (p
= ss
; p
!= NULL
; p
= p
->next
)
3363 if (p
->msymbol
== NULL
)
3365 char *string
= alloca (strlen (p
->symtab
->filename
)
3366 + strlen (SYMBOL_LINKAGE_NAME (p
->symbol
))
3368 strcpy (string
, p
->symtab
->filename
);
3369 strcat (string
, ":'");
3370 strcat (string
, SYMBOL_LINKAGE_NAME (p
->symbol
));
3371 strcat (string
, "'");
3372 break_command (string
, from_tty
);
3373 print_symbol_info (FUNCTIONS_DOMAIN
,
3377 p
->symtab
->filename
);
3381 char *string
= alloca (strlen (SYMBOL_LINKAGE_NAME (p
->msymbol
))
3383 strcpy (string
, "'");
3384 strcat (string
, SYMBOL_LINKAGE_NAME (p
->msymbol
));
3385 strcat (string
, "'");
3387 break_command (string
, from_tty
);
3388 printf_filtered ("<function, no debug info> %s;\n",
3389 SYMBOL_PRINT_NAME (p
->msymbol
));
3393 do_cleanups (old_chain
);
3397 /* Helper routine for make_symbol_completion_list. */
3399 static int return_val_size
;
3400 static int return_val_index
;
3401 static char **return_val
;
3403 #define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
3404 completion_list_add_name \
3405 (SYMBOL_NATURAL_NAME (symbol), (sym_text), (len), (text), (word))
3407 /* Test to see if the symbol specified by SYMNAME (which is already
3408 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
3409 characters. If so, add it to the current completion list. */
3412 completion_list_add_name (char *symname
, char *sym_text
, int sym_text_len
,
3413 char *text
, char *word
)
3418 /* clip symbols that cannot match */
3420 if (strncmp (symname
, sym_text
, sym_text_len
) != 0)
3425 /* We have a match for a completion, so add SYMNAME to the current list
3426 of matches. Note that the name is moved to freshly malloc'd space. */
3430 if (word
== sym_text
)
3432 new = xmalloc (strlen (symname
) + 5);
3433 strcpy (new, symname
);
3435 else if (word
> sym_text
)
3437 /* Return some portion of symname. */
3438 new = xmalloc (strlen (symname
) + 5);
3439 strcpy (new, symname
+ (word
- sym_text
));
3443 /* Return some of SYM_TEXT plus symname. */
3444 new = xmalloc (strlen (symname
) + (sym_text
- word
) + 5);
3445 strncpy (new, word
, sym_text
- word
);
3446 new[sym_text
- word
] = '\0';
3447 strcat (new, symname
);
3450 if (return_val_index
+ 3 > return_val_size
)
3452 newsize
= (return_val_size
*= 2) * sizeof (char *);
3453 return_val
= (char **) xrealloc ((char *) return_val
, newsize
);
3455 return_val
[return_val_index
++] = new;
3456 return_val
[return_val_index
] = NULL
;
3460 /* ObjC: In case we are completing on a selector, look as the msymbol
3461 again and feed all the selectors into the mill. */
3464 completion_list_objc_symbol (struct minimal_symbol
*msymbol
, char *sym_text
,
3465 int sym_text_len
, char *text
, char *word
)
3467 static char *tmp
= NULL
;
3468 static unsigned int tmplen
= 0;
3470 char *method
, *category
, *selector
;
3473 method
= SYMBOL_NATURAL_NAME (msymbol
);
3475 /* Is it a method? */
3476 if ((method
[0] != '-') && (method
[0] != '+'))
3479 if (sym_text
[0] == '[')
3480 /* Complete on shortened method method. */
3481 completion_list_add_name (method
+ 1, sym_text
, sym_text_len
, text
, word
);
3483 while ((strlen (method
) + 1) >= tmplen
)
3489 tmp
= xrealloc (tmp
, tmplen
);
3491 selector
= strchr (method
, ' ');
3492 if (selector
!= NULL
)
3495 category
= strchr (method
, '(');
3497 if ((category
!= NULL
) && (selector
!= NULL
))
3499 memcpy (tmp
, method
, (category
- method
));
3500 tmp
[category
- method
] = ' ';
3501 memcpy (tmp
+ (category
- method
) + 1, selector
, strlen (selector
) + 1);
3502 completion_list_add_name (tmp
, sym_text
, sym_text_len
, text
, word
);
3503 if (sym_text
[0] == '[')
3504 completion_list_add_name (tmp
+ 1, sym_text
, sym_text_len
, text
, word
);
3507 if (selector
!= NULL
)
3509 /* Complete on selector only. */
3510 strcpy (tmp
, selector
);
3511 tmp2
= strchr (tmp
, ']');
3515 completion_list_add_name (tmp
, sym_text
, sym_text_len
, text
, word
);
3519 /* Break the non-quoted text based on the characters which are in
3520 symbols. FIXME: This should probably be language-specific. */
3523 language_search_unquoted_string (char *text
, char *p
)
3525 for (; p
> text
; --p
)
3527 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
3531 if ((current_language
->la_language
== language_objc
))
3533 if (p
[-1] == ':') /* might be part of a method name */
3535 else if (p
[-1] == '[' && (p
[-2] == '-' || p
[-2] == '+'))
3536 p
-= 2; /* beginning of a method name */
3537 else if (p
[-1] == ' ' || p
[-1] == '(' || p
[-1] == ')')
3538 { /* might be part of a method name */
3541 /* Seeing a ' ' or a '(' is not conclusive evidence
3542 that we are in the middle of a method name. However,
3543 finding "-[" or "+[" should be pretty un-ambiguous.
3544 Unfortunately we have to find it now to decide. */
3547 if (isalnum (t
[-1]) || t
[-1] == '_' ||
3548 t
[-1] == ' ' || t
[-1] == ':' ||
3549 t
[-1] == '(' || t
[-1] == ')')
3554 if (t
[-1] == '[' && (t
[-2] == '-' || t
[-2] == '+'))
3555 p
= t
- 2; /* method name detected */
3556 /* else we leave with p unchanged */
3566 default_make_symbol_completion_list (char *text
, char *word
)
3568 /* Problem: All of the symbols have to be copied because readline
3569 frees them. I'm not going to worry about this; hopefully there
3570 won't be that many. */
3574 struct partial_symtab
*ps
;
3575 struct minimal_symbol
*msymbol
;
3576 struct objfile
*objfile
;
3577 struct block
*b
, *surrounding_static_block
= 0;
3578 struct dict_iterator iter
;
3580 struct partial_symbol
**psym
;
3581 /* The symbol we are completing on. Points in same buffer as text. */
3583 /* Length of sym_text. */
3586 /* Now look for the symbol we are supposed to complete on. */
3590 char *quote_pos
= NULL
;
3592 /* First see if this is a quoted string. */
3594 for (p
= text
; *p
!= '\0'; ++p
)
3596 if (quote_found
!= '\0')
3598 if (*p
== quote_found
)
3599 /* Found close quote. */
3601 else if (*p
== '\\' && p
[1] == quote_found
)
3602 /* A backslash followed by the quote character
3603 doesn't end the string. */
3606 else if (*p
== '\'' || *p
== '"')
3612 if (quote_found
== '\'')
3613 /* A string within single quotes can be a symbol, so complete on it. */
3614 sym_text
= quote_pos
+ 1;
3615 else if (quote_found
== '"')
3616 /* A double-quoted string is never a symbol, nor does it make sense
3617 to complete it any other way. */
3619 return_val
= (char **) xmalloc (sizeof (char *));
3620 return_val
[0] = NULL
;
3625 /* It is not a quoted string. Break it based on the characters
3626 which are in symbols. */
3629 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
3638 sym_text_len
= strlen (sym_text
);
3640 return_val_size
= 100;
3641 return_val_index
= 0;
3642 return_val
= (char **) xmalloc ((return_val_size
+ 1) * sizeof (char *));
3643 return_val
[0] = NULL
;
3645 /* Look through the partial symtabs for all symbols which begin
3646 by matching SYM_TEXT. Add each one that you find to the list. */
3648 ALL_PSYMTABS (objfile
, ps
)
3650 /* If the psymtab's been read in we'll get it when we search
3651 through the blockvector. */
3655 for (psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
3656 psym
< (objfile
->global_psymbols
.list
+ ps
->globals_offset
3657 + ps
->n_global_syms
);
3660 /* If interrupted, then quit. */
3662 COMPLETION_LIST_ADD_SYMBOL (*psym
, sym_text
, sym_text_len
, text
, word
);
3665 for (psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
3666 psym
< (objfile
->static_psymbols
.list
+ ps
->statics_offset
3667 + ps
->n_static_syms
);
3671 COMPLETION_LIST_ADD_SYMBOL (*psym
, sym_text
, sym_text_len
, text
, word
);
3675 /* At this point scan through the misc symbol vectors and add each
3676 symbol you find to the list. Eventually we want to ignore
3677 anything that isn't a text symbol (everything else will be
3678 handled by the psymtab code above). */
3680 ALL_MSYMBOLS (objfile
, msymbol
)
3683 COMPLETION_LIST_ADD_SYMBOL (msymbol
, sym_text
, sym_text_len
, text
, word
);
3685 completion_list_objc_symbol (msymbol
, sym_text
, sym_text_len
, text
, word
);
3688 /* Search upwards from currently selected frame (so that we can
3689 complete on local vars. */
3691 for (b
= get_selected_block (0); b
!= NULL
; b
= BLOCK_SUPERBLOCK (b
))
3693 if (!BLOCK_SUPERBLOCK (b
))
3695 surrounding_static_block
= b
; /* For elmin of dups */
3698 /* Also catch fields of types defined in this places which match our
3699 text string. Only complete on types visible from current context. */
3701 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
3704 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3705 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
3707 struct type
*t
= SYMBOL_TYPE (sym
);
3708 enum type_code c
= TYPE_CODE (t
);
3710 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
3712 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
3714 if (TYPE_FIELD_NAME (t
, j
))
3716 completion_list_add_name (TYPE_FIELD_NAME (t
, j
),
3717 sym_text
, sym_text_len
, text
, word
);
3725 /* Go through the symtabs and check the externs and statics for
3726 symbols which match. */
3728 ALL_PRIMARY_SYMTABS (objfile
, s
)
3731 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
3732 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
3734 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3738 ALL_PRIMARY_SYMTABS (objfile
, s
)
3741 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
3742 /* Don't do this block twice. */
3743 if (b
== surrounding_static_block
)
3745 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
3747 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3751 return (return_val
);
3754 /* Return a NULL terminated array of all symbols (regardless of class)
3755 which begin by matching TEXT. If the answer is no symbols, then
3756 the return value is an array which contains only a NULL pointer. */
3759 make_symbol_completion_list (char *text
, char *word
)
3761 return current_language
->la_make_symbol_completion_list (text
, word
);
3764 /* Like make_symbol_completion_list, but returns a list of symbols
3765 defined in a source file FILE. */
3768 make_file_symbol_completion_list (char *text
, char *word
, char *srcfile
)
3773 struct dict_iterator iter
;
3774 /* The symbol we are completing on. Points in same buffer as text. */
3776 /* Length of sym_text. */
3779 /* Now look for the symbol we are supposed to complete on.
3780 FIXME: This should be language-specific. */
3784 char *quote_pos
= NULL
;
3786 /* First see if this is a quoted string. */
3788 for (p
= text
; *p
!= '\0'; ++p
)
3790 if (quote_found
!= '\0')
3792 if (*p
== quote_found
)
3793 /* Found close quote. */
3795 else if (*p
== '\\' && p
[1] == quote_found
)
3796 /* A backslash followed by the quote character
3797 doesn't end the string. */
3800 else if (*p
== '\'' || *p
== '"')
3806 if (quote_found
== '\'')
3807 /* A string within single quotes can be a symbol, so complete on it. */
3808 sym_text
= quote_pos
+ 1;
3809 else if (quote_found
== '"')
3810 /* A double-quoted string is never a symbol, nor does it make sense
3811 to complete it any other way. */
3813 return_val
= (char **) xmalloc (sizeof (char *));
3814 return_val
[0] = NULL
;
3819 /* Not a quoted string. */
3820 sym_text
= language_search_unquoted_string (text
, p
);
3824 sym_text_len
= strlen (sym_text
);
3826 return_val_size
= 10;
3827 return_val_index
= 0;
3828 return_val
= (char **) xmalloc ((return_val_size
+ 1) * sizeof (char *));
3829 return_val
[0] = NULL
;
3831 /* Find the symtab for SRCFILE (this loads it if it was not yet read
3833 s
= lookup_symtab (srcfile
);
3836 /* Maybe they typed the file with leading directories, while the
3837 symbol tables record only its basename. */
3838 const char *tail
= lbasename (srcfile
);
3841 s
= lookup_symtab (tail
);
3844 /* If we have no symtab for that file, return an empty list. */
3846 return (return_val
);
3848 /* Go through this symtab and check the externs and statics for
3849 symbols which match. */
3851 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
3852 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
3854 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3857 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
3858 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
3860 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3863 return (return_val
);
3866 /* A helper function for make_source_files_completion_list. It adds
3867 another file name to a list of possible completions, growing the
3868 list as necessary. */
3871 add_filename_to_list (const char *fname
, char *text
, char *word
,
3872 char ***list
, int *list_used
, int *list_alloced
)
3875 size_t fnlen
= strlen (fname
);
3877 if (*list_used
+ 1 >= *list_alloced
)
3880 *list
= (char **) xrealloc ((char *) *list
,
3881 *list_alloced
* sizeof (char *));
3886 /* Return exactly fname. */
3887 new = xmalloc (fnlen
+ 5);
3888 strcpy (new, fname
);
3890 else if (word
> text
)
3892 /* Return some portion of fname. */
3893 new = xmalloc (fnlen
+ 5);
3894 strcpy (new, fname
+ (word
- text
));
3898 /* Return some of TEXT plus fname. */
3899 new = xmalloc (fnlen
+ (text
- word
) + 5);
3900 strncpy (new, word
, text
- word
);
3901 new[text
- word
] = '\0';
3902 strcat (new, fname
);
3904 (*list
)[*list_used
] = new;
3905 (*list
)[++*list_used
] = NULL
;
3909 not_interesting_fname (const char *fname
)
3911 static const char *illegal_aliens
[] = {
3912 "_globals_", /* inserted by coff_symtab_read */
3917 for (i
= 0; illegal_aliens
[i
]; i
++)
3919 if (strcmp (fname
, illegal_aliens
[i
]) == 0)
3925 /* Return a NULL terminated array of all source files whose names
3926 begin with matching TEXT. The file names are looked up in the
3927 symbol tables of this program. If the answer is no matchess, then
3928 the return value is an array which contains only a NULL pointer. */
3931 make_source_files_completion_list (char *text
, char *word
)
3934 struct partial_symtab
*ps
;
3935 struct objfile
*objfile
;
3937 int list_alloced
= 1;
3939 size_t text_len
= strlen (text
);
3940 char **list
= (char **) xmalloc (list_alloced
* sizeof (char *));
3941 const char *base_name
;
3945 if (!have_full_symbols () && !have_partial_symbols ())
3948 ALL_SYMTABS (objfile
, s
)
3950 if (not_interesting_fname (s
->filename
))
3952 if (!filename_seen (s
->filename
, 1, &first
)
3953 #if HAVE_DOS_BASED_FILE_SYSTEM
3954 && strncasecmp (s
->filename
, text
, text_len
) == 0
3956 && strncmp (s
->filename
, text
, text_len
) == 0
3960 /* This file matches for a completion; add it to the current
3962 add_filename_to_list (s
->filename
, text
, word
,
3963 &list
, &list_used
, &list_alloced
);
3967 /* NOTE: We allow the user to type a base name when the
3968 debug info records leading directories, but not the other
3969 way around. This is what subroutines of breakpoint
3970 command do when they parse file names. */
3971 base_name
= lbasename (s
->filename
);
3972 if (base_name
!= s
->filename
3973 && !filename_seen (base_name
, 1, &first
)
3974 #if HAVE_DOS_BASED_FILE_SYSTEM
3975 && strncasecmp (base_name
, text
, text_len
) == 0
3977 && strncmp (base_name
, text
, text_len
) == 0
3980 add_filename_to_list (base_name
, text
, word
,
3981 &list
, &list_used
, &list_alloced
);
3985 ALL_PSYMTABS (objfile
, ps
)
3987 if (not_interesting_fname (ps
->filename
))
3991 if (!filename_seen (ps
->filename
, 1, &first
)
3992 #if HAVE_DOS_BASED_FILE_SYSTEM
3993 && strncasecmp (ps
->filename
, text
, text_len
) == 0
3995 && strncmp (ps
->filename
, text
, text_len
) == 0
3999 /* This file matches for a completion; add it to the
4000 current list of matches. */
4001 add_filename_to_list (ps
->filename
, text
, word
,
4002 &list
, &list_used
, &list_alloced
);
4007 base_name
= lbasename (ps
->filename
);
4008 if (base_name
!= ps
->filename
4009 && !filename_seen (base_name
, 1, &first
)
4010 #if HAVE_DOS_BASED_FILE_SYSTEM
4011 && strncasecmp (base_name
, text
, text_len
) == 0
4013 && strncmp (base_name
, text
, text_len
) == 0
4016 add_filename_to_list (base_name
, text
, word
,
4017 &list
, &list_used
, &list_alloced
);
4025 /* Determine if PC is in the prologue of a function. The prologue is the area
4026 between the first instruction of a function, and the first executable line.
4027 Returns 1 if PC *might* be in prologue, 0 if definately *not* in prologue.
4029 If non-zero, func_start is where we think the prologue starts, possibly
4030 by previous examination of symbol table information.
4034 in_prologue (CORE_ADDR pc
, CORE_ADDR func_start
)
4036 struct symtab_and_line sal
;
4037 CORE_ADDR func_addr
, func_end
;
4039 /* We have several sources of information we can consult to figure
4041 - Compilers usually emit line number info that marks the prologue
4042 as its own "source line". So the ending address of that "line"
4043 is the end of the prologue. If available, this is the most
4045 - The minimal symbols and partial symbols, which can usually tell
4046 us the starting and ending addresses of a function.
4047 - If we know the function's start address, we can call the
4048 architecture-defined gdbarch_skip_prologue function to analyze the
4049 instruction stream and guess where the prologue ends.
4050 - Our `func_start' argument; if non-zero, this is the caller's
4051 best guess as to the function's entry point. At the time of
4052 this writing, handle_inferior_event doesn't get this right, so
4053 it should be our last resort. */
4055 /* Consult the partial symbol table, to find which function
4057 if (! find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
4059 CORE_ADDR prologue_end
;
4061 /* We don't even have minsym information, so fall back to using
4062 func_start, if given. */
4064 return 1; /* We *might* be in a prologue. */
4066 prologue_end
= gdbarch_skip_prologue (current_gdbarch
, func_start
);
4068 return func_start
<= pc
&& pc
< prologue_end
;
4071 /* If we have line number information for the function, that's
4072 usually pretty reliable. */
4073 sal
= find_pc_line (func_addr
, 0);
4075 /* Now sal describes the source line at the function's entry point,
4076 which (by convention) is the prologue. The end of that "line",
4077 sal.end, is the end of the prologue.
4079 Note that, for functions whose source code is all on a single
4080 line, the line number information doesn't always end up this way.
4081 So we must verify that our purported end-of-prologue address is
4082 *within* the function, not at its start or end. */
4084 || sal
.end
<= func_addr
4085 || func_end
<= sal
.end
)
4087 /* We don't have any good line number info, so use the minsym
4088 information, together with the architecture-specific prologue
4090 CORE_ADDR prologue_end
= gdbarch_skip_prologue
4091 (current_gdbarch
, func_addr
);
4093 return func_addr
<= pc
&& pc
< prologue_end
;
4096 /* We have line number info, and it looks good. */
4097 return func_addr
<= pc
&& pc
< sal
.end
;
4100 /* Given PC at the function's start address, attempt to find the
4101 prologue end using SAL information. Return zero if the skip fails.
4103 A non-optimized prologue traditionally has one SAL for the function
4104 and a second for the function body. A single line function has
4105 them both pointing at the same line.
4107 An optimized prologue is similar but the prologue may contain
4108 instructions (SALs) from the instruction body. Need to skip those
4109 while not getting into the function body.
4111 The functions end point and an increasing SAL line are used as
4112 indicators of the prologue's endpoint.
4114 This code is based on the function refine_prologue_limit (versions
4115 found in both ia64 and ppc). */
4118 skip_prologue_using_sal (CORE_ADDR func_addr
)
4120 struct symtab_and_line prologue_sal
;
4124 /* Get an initial range for the function. */
4125 find_pc_partial_function (func_addr
, NULL
, &start_pc
, &end_pc
);
4126 start_pc
+= gdbarch_deprecated_function_start_offset (current_gdbarch
);
4128 prologue_sal
= find_pc_line (start_pc
, 0);
4129 if (prologue_sal
.line
!= 0)
4131 /* If there is only one sal that covers the entire function,
4132 then it is probably a single line function, like
4134 if (prologue_sal
.end
>= end_pc
)
4136 while (prologue_sal
.end
< end_pc
)
4138 struct symtab_and_line sal
;
4140 sal
= find_pc_line (prologue_sal
.end
, 0);
4143 /* Assume that a consecutive SAL for the same (or larger)
4144 line mark the prologue -> body transition. */
4145 if (sal
.line
>= prologue_sal
.line
)
4147 /* The case in which compiler's optimizer/scheduler has
4148 moved instructions into the prologue. We look ahead in
4149 the function looking for address ranges whose
4150 corresponding line number is less the first one that we
4151 found for the function. This is more conservative then
4152 refine_prologue_limit which scans a large number of SALs
4153 looking for any in the prologue */
4157 return prologue_sal
.end
;
4160 struct symtabs_and_lines
4161 decode_line_spec (char *string
, int funfirstline
)
4163 struct symtabs_and_lines sals
;
4164 struct symtab_and_line cursal
;
4167 error (_("Empty line specification."));
4169 /* We use whatever is set as the current source line. We do not try
4170 and get a default or it will recursively call us! */
4171 cursal
= get_current_source_symtab_and_line ();
4173 sals
= decode_line_1 (&string
, funfirstline
,
4174 cursal
.symtab
, cursal
.line
,
4175 (char ***) NULL
, NULL
);
4178 error (_("Junk at end of line specification: %s"), string
);
4183 static char *name_of_main
;
4186 set_main_name (const char *name
)
4188 if (name_of_main
!= NULL
)
4190 xfree (name_of_main
);
4191 name_of_main
= NULL
;
4195 name_of_main
= xstrdup (name
);
4199 /* Deduce the name of the main procedure, and set NAME_OF_MAIN
4203 find_main_name (void)
4205 const char *new_main_name
;
4207 /* Try to see if the main procedure is in Ada. */
4208 /* FIXME: brobecker/2005-03-07: Another way of doing this would
4209 be to add a new method in the language vector, and call this
4210 method for each language until one of them returns a non-empty
4211 name. This would allow us to remove this hard-coded call to
4212 an Ada function. It is not clear that this is a better approach
4213 at this point, because all methods need to be written in a way
4214 such that false positives never be returned. For instance, it is
4215 important that a method does not return a wrong name for the main
4216 procedure if the main procedure is actually written in a different
4217 language. It is easy to guaranty this with Ada, since we use a
4218 special symbol generated only when the main in Ada to find the name
4219 of the main procedure. It is difficult however to see how this can
4220 be guarantied for languages such as C, for instance. This suggests
4221 that order of call for these methods becomes important, which means
4222 a more complicated approach. */
4223 new_main_name
= ada_main_name ();
4224 if (new_main_name
!= NULL
)
4226 set_main_name (new_main_name
);
4230 new_main_name
= pascal_main_name ();
4231 if (new_main_name
!= NULL
)
4233 set_main_name (new_main_name
);
4237 /* The languages above didn't identify the name of the main procedure.
4238 Fallback to "main". */
4239 set_main_name ("main");
4245 if (name_of_main
== NULL
)
4248 return name_of_main
;
4251 /* Handle ``executable_changed'' events for the symtab module. */
4254 symtab_observer_executable_changed (void *unused
)
4256 /* NAME_OF_MAIN may no longer be the same, so reset it for now. */
4257 set_main_name (NULL
);
4260 /* Helper to expand_line_sal below. Appends new sal to SAL,
4261 initializing it from SYMTAB, LINENO and PC. */
4263 append_expanded_sal (struct symtabs_and_lines
*sal
,
4264 struct symtab
*symtab
,
4265 int lineno
, CORE_ADDR pc
)
4267 CORE_ADDR func_addr
, func_end
;
4269 sal
->sals
= xrealloc (sal
->sals
,
4270 sizeof (sal
->sals
[0])
4271 * (sal
->nelts
+ 1));
4272 init_sal (sal
->sals
+ sal
->nelts
);
4273 sal
->sals
[sal
->nelts
].symtab
= symtab
;
4274 sal
->sals
[sal
->nelts
].section
= NULL
;
4275 sal
->sals
[sal
->nelts
].end
= 0;
4276 sal
->sals
[sal
->nelts
].line
= lineno
;
4277 sal
->sals
[sal
->nelts
].pc
= pc
;
4281 /* Compute a set of all sals in
4282 the entire program that correspond to same file
4283 and line as SAL and return those. If there
4284 are several sals that belong to the same block,
4285 only one sal for the block is included in results. */
4287 struct symtabs_and_lines
4288 expand_line_sal (struct symtab_and_line sal
)
4290 struct symtabs_and_lines ret
, this_line
;
4292 struct objfile
*objfile
;
4293 struct partial_symtab
*psymtab
;
4294 struct symtab
*symtab
;
4297 struct block
**blocks
= NULL
;
4303 if (sal
.symtab
== NULL
|| sal
.line
== 0 || sal
.pc
!= 0)
4305 ret
.sals
= xmalloc (sizeof (struct symtab_and_line
));
4312 struct linetable_entry
*best_item
= 0;
4313 struct symtab
*best_symtab
= 0;
4318 /* We meed to find all symtabs for a file which name
4319 is described by sal. We cannot just directly
4320 iterate over symtabs, since a symtab might not be
4321 yet created. We also cannot iterate over psymtabs,
4322 calling PSYMTAB_TO_SYMTAB and working on that symtab,
4323 since PSYMTAB_TO_SYMTAB will return NULL for psymtab
4324 corresponding to an included file. Therefore, we do
4325 first pass over psymtabs, reading in those with
4326 the right name. Then, we iterate over symtabs, knowing
4327 that all symtabs we're interested in are loaded. */
4329 ALL_PSYMTABS (objfile
, psymtab
)
4331 if (strcmp (sal
.symtab
->filename
,
4332 psymtab
->filename
) == 0)
4333 PSYMTAB_TO_SYMTAB (psymtab
);
4337 /* For each symtab, we add all pcs to ret.sals. I'm actually
4338 not sure what to do if we have exact match in one symtab,
4339 and non-exact match on another symtab.
4341 ALL_SYMTABS (objfile
, symtab
)
4343 if (strcmp (sal
.symtab
->filename
,
4344 symtab
->filename
) == 0)
4346 struct linetable
*l
;
4348 l
= LINETABLE (symtab
);
4353 for (j
= 0; j
< len
; j
++)
4355 struct linetable_entry
*item
= &(l
->item
[j
]);
4357 if (item
->line
== lineno
)
4360 append_expanded_sal (&ret
, symtab
, lineno
, item
->pc
);
4362 else if (!exact
&& item
->line
> lineno
4363 && (best_item
== NULL
|| item
->line
< best_item
->line
))
4367 best_symtab
= symtab
;
4372 if (!exact
&& best_item
)
4373 append_expanded_sal (&ret
, best_symtab
, lineno
, best_item
->pc
);
4376 /* For optimized code, compiler can scatter one source line accross
4377 disjoint ranges of PC values, even when no duplicate functions
4378 or inline functions are involved. For example, 'for (;;)' inside
4379 non-template non-inline non-ctor-or-dtor function can result
4380 in two PC ranges. In this case, we don't want to set breakpoint
4381 on first PC of each range. To filter such cases, we use containing
4382 blocks -- for each PC found above we see if there are other PCs
4383 that are in the same block. If yes, the other PCs are filtered out. */
4385 filter
= xmalloc (ret
.nelts
* sizeof (int));
4386 blocks
= xmalloc (ret
.nelts
* sizeof (struct block
*));
4387 for (i
= 0; i
< ret
.nelts
; ++i
)
4390 blocks
[i
] = block_for_pc (ret
.sals
[i
].pc
);
4393 for (i
= 0; i
< ret
.nelts
; ++i
)
4394 if (blocks
[i
] != NULL
)
4395 for (j
= i
+1; j
< ret
.nelts
; ++j
)
4396 if (blocks
[j
] == blocks
[i
])
4404 struct symtab_and_line
*final
=
4405 xmalloc (sizeof (struct symtab_and_line
) * (ret
.nelts
-deleted
));
4407 for (i
= 0, j
= 0; i
< ret
.nelts
; ++i
)
4409 final
[j
++] = ret
.sals
[i
];
4411 ret
.nelts
-= deleted
;
4421 _initialize_symtab (void)
4423 add_info ("variables", variables_info
, _("\
4424 All global and static variable names, or those matching REGEXP."));
4426 add_com ("whereis", class_info
, variables_info
, _("\
4427 All global and static variable names, or those matching REGEXP."));
4429 add_info ("functions", functions_info
,
4430 _("All function names, or those matching REGEXP."));
4433 /* FIXME: This command has at least the following problems:
4434 1. It prints builtin types (in a very strange and confusing fashion).
4435 2. It doesn't print right, e.g. with
4436 typedef struct foo *FOO
4437 type_print prints "FOO" when we want to make it (in this situation)
4438 print "struct foo *".
4439 I also think "ptype" or "whatis" is more likely to be useful (but if
4440 there is much disagreement "info types" can be fixed). */
4441 add_info ("types", types_info
,
4442 _("All type names, or those matching REGEXP."));
4444 add_info ("sources", sources_info
,
4445 _("Source files in the program."));
4447 add_com ("rbreak", class_breakpoint
, rbreak_command
,
4448 _("Set a breakpoint for all functions matching REGEXP."));
4452 add_com ("lf", class_info
, sources_info
,
4453 _("Source files in the program"));
4454 add_com ("lg", class_info
, variables_info
, _("\
4455 All global and static variable names, or those matching REGEXP."));
4458 add_setshow_enum_cmd ("multiple-symbols", no_class
,
4459 multiple_symbols_modes
, &multiple_symbols_mode
,
4461 Set the debugger behavior when more than one symbol are possible matches\n\
4462 in an expression."), _("\
4463 Show how the debugger handles ambiguities in expressions."), _("\
4464 Valid values are \"ask\", \"all\", \"cancel\", and the default is \"all\"."),
4465 NULL
, NULL
, &setlist
, &showlist
);
4467 /* Initialize the one built-in type that isn't language dependent... */
4468 builtin_type_error
= init_type (TYPE_CODE_ERROR
, 0, 0,
4469 "<unknown type>", (struct objfile
*) NULL
);
4471 observer_attach_executable_changed (symtab_observer_executable_changed
);