1 /* Symbol table lookup for the GNU debugger, GDB.
3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
4 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
34 #include "call-cmds.h"
35 #include "gdb_regex.h"
36 #include "expression.h"
42 #include "filenames.h" /* for FILENAME_CMP */
43 #include "objc-lang.h"
48 #include "gdb_obstack.h"
50 #include "dictionary.h"
52 #include <sys/types.h>
54 #include "gdb_string.h"
59 /* Prototypes for local functions */
61 static void completion_list_add_name (char *, char *, int, char *, char *);
63 static void rbreak_command (char *, int);
65 static void types_info (char *, int);
67 static void functions_info (char *, int);
69 static void variables_info (char *, int);
71 static void sources_info (char *, int);
73 static void output_source_filename (const char *, int *);
75 static int find_line_common (struct linetable
*, int, int *);
77 /* This one is used by linespec.c */
79 char *operator_chars (char *p
, char **end
);
81 static struct symbol
*lookup_symbol_aux (const char *name
,
82 const char *linkage_name
,
83 const struct block
*block
,
84 const domain_enum domain
,
85 int *is_a_field_of_this
,
86 struct symtab
**symtab
);
89 struct symbol
*lookup_symbol_aux_local (const char *name
,
90 const char *linkage_name
,
91 const struct block
*block
,
92 const domain_enum domain
,
93 struct symtab
**symtab
);
96 struct symbol
*lookup_symbol_aux_symtabs (int block_index
,
98 const char *linkage_name
,
99 const domain_enum domain
,
100 struct symtab
**symtab
);
103 struct symbol
*lookup_symbol_aux_psymtabs (int block_index
,
105 const char *linkage_name
,
106 const domain_enum domain
,
107 struct symtab
**symtab
);
111 struct symbol
*lookup_symbol_aux_minsyms (const char *name
,
112 const char *linkage_name
,
113 const domain_enum domain
,
114 int *is_a_field_of_this
,
115 struct symtab
**symtab
);
118 /* This flag is used in hppa-tdep.c, and set in hp-symtab-read.c.
119 Signals the presence of objects compiled by HP compilers. */
120 int deprecated_hp_som_som_object_present
= 0;
122 static void fixup_section (struct general_symbol_info
*, struct objfile
*);
124 static int file_matches (char *, char **, int);
126 static void print_symbol_info (domain_enum
,
127 struct symtab
*, struct symbol
*, int, char *);
129 static void print_msymbol_info (struct minimal_symbol
*);
131 static void symtab_symbol_info (char *, domain_enum
, int);
133 void _initialize_symtab (void);
137 /* The single non-language-specific builtin type */
138 struct type
*builtin_type_error
;
140 /* Block in which the most recently searched-for symbol was found.
141 Might be better to make this a parameter to lookup_symbol and
144 const struct block
*block_found
;
146 /* Check for a symtab of a specific name; first in symtabs, then in
147 psymtabs. *If* there is no '/' in the name, a match after a '/'
148 in the symtab filename will also work. */
151 lookup_symtab (const char *name
)
154 struct partial_symtab
*ps
;
155 struct objfile
*objfile
;
156 char *real_path
= NULL
;
157 char *full_path
= NULL
;
159 /* Here we are interested in canonicalizing an absolute path, not
160 absolutizing a relative path. */
161 if (IS_ABSOLUTE_PATH (name
))
163 full_path
= xfullpath (name
);
164 make_cleanup (xfree
, full_path
);
165 real_path
= gdb_realpath (name
);
166 make_cleanup (xfree
, real_path
);
171 /* First, search for an exact match */
173 ALL_SYMTABS (objfile
, s
)
175 if (FILENAME_CMP (name
, s
->filename
) == 0)
180 /* If the user gave us an absolute path, try to find the file in
181 this symtab and use its absolute path. */
183 if (full_path
!= NULL
)
185 const char *fp
= symtab_to_fullname (s
);
186 if (fp
!= NULL
&& FILENAME_CMP (full_path
, fp
) == 0)
192 if (real_path
!= NULL
)
194 char *fullname
= symtab_to_fullname (s
);
195 if (fullname
!= NULL
)
197 char *rp
= gdb_realpath (fullname
);
198 make_cleanup (xfree
, rp
);
199 if (FILENAME_CMP (real_path
, rp
) == 0)
207 /* Now, search for a matching tail (only if name doesn't have any dirs) */
209 if (lbasename (name
) == name
)
210 ALL_SYMTABS (objfile
, s
)
212 if (FILENAME_CMP (lbasename (s
->filename
), name
) == 0)
216 /* Same search rules as above apply here, but now we look thru the
219 ps
= lookup_partial_symtab (name
);
224 error ("Internal: readin %s pst for `%s' found when no symtab found.",
227 s
= PSYMTAB_TO_SYMTAB (ps
);
232 /* At this point, we have located the psymtab for this file, but
233 the conversion to a symtab has failed. This usually happens
234 when we are looking up an include file. In this case,
235 PSYMTAB_TO_SYMTAB doesn't return a symtab, even though one has
236 been created. So, we need to run through the symtabs again in
237 order to find the file.
238 XXX - This is a crock, and should be fixed inside of the the
239 symbol parsing routines. */
243 /* Lookup the partial symbol table of a source file named NAME.
244 *If* there is no '/' in the name, a match after a '/'
245 in the psymtab filename will also work. */
247 struct partial_symtab
*
248 lookup_partial_symtab (const char *name
)
250 struct partial_symtab
*pst
;
251 struct objfile
*objfile
;
252 char *full_path
= NULL
;
253 char *real_path
= NULL
;
255 /* Here we are interested in canonicalizing an absolute path, not
256 absolutizing a relative path. */
257 if (IS_ABSOLUTE_PATH (name
))
259 full_path
= xfullpath (name
);
260 make_cleanup (xfree
, full_path
);
261 real_path
= gdb_realpath (name
);
262 make_cleanup (xfree
, real_path
);
265 ALL_PSYMTABS (objfile
, pst
)
267 if (FILENAME_CMP (name
, pst
->filename
) == 0)
272 /* If the user gave us an absolute path, try to find the file in
273 this symtab and use its absolute path. */
274 if (full_path
!= NULL
)
276 psymtab_to_fullname (pst
);
277 if (pst
->fullname
!= NULL
278 && FILENAME_CMP (full_path
, pst
->fullname
) == 0)
284 if (real_path
!= NULL
)
287 psymtab_to_fullname (pst
);
288 if (pst
->fullname
!= NULL
)
290 rp
= gdb_realpath (pst
->fullname
);
291 make_cleanup (xfree
, rp
);
293 if (rp
!= NULL
&& FILENAME_CMP (real_path
, rp
) == 0)
300 /* Now, search for a matching tail (only if name doesn't have any dirs) */
302 if (lbasename (name
) == name
)
303 ALL_PSYMTABS (objfile
, pst
)
305 if (FILENAME_CMP (lbasename (pst
->filename
), name
) == 0)
312 /* Mangle a GDB method stub type. This actually reassembles the pieces of the
313 full method name, which consist of the class name (from T), the unadorned
314 method name from METHOD_ID, and the signature for the specific overload,
315 specified by SIGNATURE_ID. Note that this function is g++ specific. */
318 gdb_mangle_name (struct type
*type
, int method_id
, int signature_id
)
320 int mangled_name_len
;
322 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
323 struct fn_field
*method
= &f
[signature_id
];
324 char *field_name
= TYPE_FN_FIELDLIST_NAME (type
, method_id
);
325 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, signature_id
);
326 char *newname
= type_name_no_tag (type
);
328 /* Does the form of physname indicate that it is the full mangled name
329 of a constructor (not just the args)? */
330 int is_full_physname_constructor
;
333 int is_destructor
= is_destructor_name (physname
);
334 /* Need a new type prefix. */
335 char *const_prefix
= method
->is_const
? "C" : "";
336 char *volatile_prefix
= method
->is_volatile
? "V" : "";
338 int len
= (newname
== NULL
? 0 : strlen (newname
));
340 /* Nothing to do if physname already contains a fully mangled v3 abi name
341 or an operator name. */
342 if ((physname
[0] == '_' && physname
[1] == 'Z')
343 || is_operator_name (field_name
))
344 return xstrdup (physname
);
346 is_full_physname_constructor
= is_constructor_name (physname
);
349 is_full_physname_constructor
|| (newname
&& strcmp (field_name
, newname
) == 0);
352 is_destructor
= (strncmp (physname
, "__dt", 4) == 0);
354 if (is_destructor
|| is_full_physname_constructor
)
356 mangled_name
= (char *) xmalloc (strlen (physname
) + 1);
357 strcpy (mangled_name
, physname
);
363 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
365 else if (physname
[0] == 't' || physname
[0] == 'Q')
367 /* The physname for template and qualified methods already includes
369 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
375 sprintf (buf
, "__%s%s%d", const_prefix
, volatile_prefix
, len
);
377 mangled_name_len
= ((is_constructor
? 0 : strlen (field_name
))
378 + strlen (buf
) + len
+ strlen (physname
) + 1);
381 mangled_name
= (char *) xmalloc (mangled_name_len
);
383 mangled_name
[0] = '\0';
385 strcpy (mangled_name
, field_name
);
387 strcat (mangled_name
, buf
);
388 /* If the class doesn't have a name, i.e. newname NULL, then we just
389 mangle it using 0 for the length of the class. Thus it gets mangled
390 as something starting with `::' rather than `classname::'. */
392 strcat (mangled_name
, newname
);
394 strcat (mangled_name
, physname
);
395 return (mangled_name
);
399 /* Initialize the language dependent portion of a symbol
400 depending upon the language for the symbol. */
402 symbol_init_language_specific (struct general_symbol_info
*gsymbol
,
403 enum language language
)
405 gsymbol
->language
= language
;
406 if (gsymbol
->language
== language_cplus
407 || gsymbol
->language
== language_java
408 || gsymbol
->language
== language_objc
)
410 gsymbol
->language_specific
.cplus_specific
.demangled_name
= NULL
;
414 memset (&gsymbol
->language_specific
, 0,
415 sizeof (gsymbol
->language_specific
));
419 /* Functions to initialize a symbol's mangled name. */
421 /* Create the hash table used for demangled names. Each hash entry is
422 a pair of strings; one for the mangled name and one for the demangled
423 name. The entry is hashed via just the mangled name. */
426 create_demangled_names_hash (struct objfile
*objfile
)
428 /* Choose 256 as the starting size of the hash table, somewhat arbitrarily.
429 The hash table code will round this up to the next prime number.
430 Choosing a much larger table size wastes memory, and saves only about
431 1% in symbol reading. */
433 objfile
->demangled_names_hash
= htab_create_alloc
434 (256, htab_hash_string
, (int (*) (const void *, const void *)) streq
,
435 NULL
, xcalloc
, xfree
);
438 /* Try to determine the demangled name for a symbol, based on the
439 language of that symbol. If the language is set to language_auto,
440 it will attempt to find any demangling algorithm that works and
441 then set the language appropriately. The returned name is allocated
442 by the demangler and should be xfree'd. */
445 symbol_find_demangled_name (struct general_symbol_info
*gsymbol
,
448 char *demangled
= NULL
;
450 if (gsymbol
->language
== language_unknown
)
451 gsymbol
->language
= language_auto
;
453 if (gsymbol
->language
== language_objc
454 || gsymbol
->language
== language_auto
)
457 objc_demangle (mangled
, 0);
458 if (demangled
!= NULL
)
460 gsymbol
->language
= language_objc
;
464 if (gsymbol
->language
== language_cplus
465 || gsymbol
->language
== language_auto
)
468 cplus_demangle (mangled
, DMGL_PARAMS
| DMGL_ANSI
);
469 if (demangled
!= NULL
)
471 gsymbol
->language
= language_cplus
;
475 if (gsymbol
->language
== language_java
)
478 cplus_demangle (mangled
,
479 DMGL_PARAMS
| DMGL_ANSI
| DMGL_JAVA
);
480 if (demangled
!= NULL
)
482 gsymbol
->language
= language_java
;
489 /* Set both the mangled and demangled (if any) names for GSYMBOL based
490 on LINKAGE_NAME and LEN. The hash table corresponding to OBJFILE
491 is used, and the memory comes from that objfile's objfile_obstack.
492 LINKAGE_NAME is copied, so the pointer can be discarded after
493 calling this function. */
495 /* We have to be careful when dealing with Java names: when we run
496 into a Java minimal symbol, we don't know it's a Java symbol, so it
497 gets demangled as a C++ name. This is unfortunate, but there's not
498 much we can do about it: but when demangling partial symbols and
499 regular symbols, we'd better not reuse the wrong demangled name.
500 (See PR gdb/1039.) We solve this by putting a distinctive prefix
501 on Java names when storing them in the hash table. */
503 /* FIXME: carlton/2003-03-13: This is an unfortunate situation. I
504 don't mind the Java prefix so much: different languages have
505 different demangling requirements, so it's only natural that we
506 need to keep language data around in our demangling cache. But
507 it's not good that the minimal symbol has the wrong demangled name.
508 Unfortunately, I can't think of any easy solution to that
511 #define JAVA_PREFIX "##JAVA$$"
512 #define JAVA_PREFIX_LEN 8
515 symbol_set_names (struct general_symbol_info
*gsymbol
,
516 const char *linkage_name
, int len
, struct objfile
*objfile
)
519 /* A 0-terminated copy of the linkage name. */
520 const char *linkage_name_copy
;
521 /* A copy of the linkage name that might have a special Java prefix
522 added to it, for use when looking names up in the hash table. */
523 const char *lookup_name
;
524 /* The length of lookup_name. */
527 if (objfile
->demangled_names_hash
== NULL
)
528 create_demangled_names_hash (objfile
);
530 /* The stabs reader generally provides names that are not
531 NUL-terminated; most of the other readers don't do this, so we
532 can just use the given copy, unless we're in the Java case. */
533 if (gsymbol
->language
== language_java
)
536 lookup_len
= len
+ JAVA_PREFIX_LEN
;
538 alloc_name
= alloca (lookup_len
+ 1);
539 memcpy (alloc_name
, JAVA_PREFIX
, JAVA_PREFIX_LEN
);
540 memcpy (alloc_name
+ JAVA_PREFIX_LEN
, linkage_name
, len
);
541 alloc_name
[lookup_len
] = '\0';
543 lookup_name
= alloc_name
;
544 linkage_name_copy
= alloc_name
+ JAVA_PREFIX_LEN
;
546 else if (linkage_name
[len
] != '\0')
551 alloc_name
= alloca (lookup_len
+ 1);
552 memcpy (alloc_name
, linkage_name
, len
);
553 alloc_name
[lookup_len
] = '\0';
555 lookup_name
= alloc_name
;
556 linkage_name_copy
= alloc_name
;
561 lookup_name
= linkage_name
;
562 linkage_name_copy
= linkage_name
;
565 slot
= (char **) htab_find_slot (objfile
->demangled_names_hash
,
566 lookup_name
, INSERT
);
568 /* If this name is not in the hash table, add it. */
571 char *demangled_name
= symbol_find_demangled_name (gsymbol
,
573 int demangled_len
= demangled_name
? strlen (demangled_name
) : 0;
575 /* If there is a demangled name, place it right after the mangled name.
576 Otherwise, just place a second zero byte after the end of the mangled
578 *slot
= obstack_alloc (&objfile
->objfile_obstack
,
579 lookup_len
+ demangled_len
+ 2);
580 memcpy (*slot
, lookup_name
, lookup_len
+ 1);
581 if (demangled_name
!= NULL
)
583 memcpy (*slot
+ lookup_len
+ 1, demangled_name
, demangled_len
+ 1);
584 xfree (demangled_name
);
587 (*slot
)[lookup_len
+ 1] = '\0';
590 gsymbol
->name
= *slot
+ lookup_len
- len
;
591 if ((*slot
)[lookup_len
+ 1] != '\0')
592 gsymbol
->language_specific
.cplus_specific
.demangled_name
593 = &(*slot
)[lookup_len
+ 1];
595 gsymbol
->language_specific
.cplus_specific
.demangled_name
= NULL
;
598 /* Initialize the demangled name of GSYMBOL if possible. Any required space
599 to store the name is obtained from the specified obstack. The function
600 symbol_set_names, above, should be used instead where possible for more
601 efficient memory usage. */
604 symbol_init_demangled_name (struct general_symbol_info
*gsymbol
,
605 struct obstack
*obstack
)
607 char *mangled
= gsymbol
->name
;
608 char *demangled
= NULL
;
610 demangled
= symbol_find_demangled_name (gsymbol
, mangled
);
611 if (gsymbol
->language
== language_cplus
612 || gsymbol
->language
== language_java
613 || gsymbol
->language
== language_objc
)
617 gsymbol
->language_specific
.cplus_specific
.demangled_name
618 = obsavestring (demangled
, strlen (demangled
), obstack
);
622 gsymbol
->language_specific
.cplus_specific
.demangled_name
= NULL
;
626 /* Unknown language; just clean up quietly. */
632 /* Return the source code name of a symbol. In languages where
633 demangling is necessary, this is the demangled name. */
636 symbol_natural_name (const struct general_symbol_info
*gsymbol
)
638 switch (gsymbol
->language
)
643 if (gsymbol
->language_specific
.cplus_specific
.demangled_name
!= NULL
)
644 return gsymbol
->language_specific
.cplus_specific
.demangled_name
;
647 if (gsymbol
->language_specific
.cplus_specific
.demangled_name
!= NULL
)
648 return gsymbol
->language_specific
.cplus_specific
.demangled_name
;
650 return ada_decode_symbol (gsymbol
);
655 return gsymbol
->name
;
658 /* Return the demangled name for a symbol based on the language for
659 that symbol. If no demangled name exists, return NULL. */
661 symbol_demangled_name (struct general_symbol_info
*gsymbol
)
663 switch (gsymbol
->language
)
668 if (gsymbol
->language_specific
.cplus_specific
.demangled_name
!= NULL
)
669 return gsymbol
->language_specific
.cplus_specific
.demangled_name
;
672 if (gsymbol
->language_specific
.cplus_specific
.demangled_name
!= NULL
)
673 return gsymbol
->language_specific
.cplus_specific
.demangled_name
;
675 return ada_decode_symbol (gsymbol
);
683 /* Return the search name of a symbol---generally the demangled or
684 linkage name of the symbol, depending on how it will be searched for.
685 If there is no distinct demangled name, then returns the same value
686 (same pointer) as SYMBOL_LINKAGE_NAME. */
687 char *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
)
707 /* Find which partial symtab contains PC and SECTION. Return 0 if
708 none. We return the psymtab that contains a symbol whose address
709 exactly matches PC, or, if we cannot find an exact match, the
710 psymtab that contains a symbol whose address is closest to PC. */
711 struct partial_symtab
*
712 find_pc_sect_psymtab (CORE_ADDR pc
, asection
*section
)
714 struct partial_symtab
*pst
;
715 struct objfile
*objfile
;
716 struct minimal_symbol
*msymbol
;
718 /* If we know that this is not a text address, return failure. This is
719 necessary because we loop based on texthigh and textlow, which do
720 not include the data ranges. */
721 msymbol
= lookup_minimal_symbol_by_pc_section (pc
, section
);
723 && (msymbol
->type
== mst_data
724 || msymbol
->type
== mst_bss
725 || msymbol
->type
== mst_abs
726 || msymbol
->type
== mst_file_data
727 || msymbol
->type
== mst_file_bss
))
730 ALL_PSYMTABS (objfile
, pst
)
732 if (pc
>= pst
->textlow
&& pc
< pst
->texthigh
)
734 struct partial_symtab
*tpst
;
735 struct partial_symtab
*best_pst
= pst
;
736 struct partial_symbol
*best_psym
= NULL
;
738 /* An objfile that has its functions reordered might have
739 many partial symbol tables containing the PC, but
740 we want the partial symbol table that contains the
741 function containing the PC. */
742 if (!(objfile
->flags
& OBJF_REORDERED
) &&
743 section
== 0) /* can't validate section this way */
749 /* The code range of partial symtabs sometimes overlap, so, in
750 the loop below, we need to check all partial symtabs and
751 find the one that fits better for the given PC address. We
752 select the partial symtab that contains a symbol whose
753 address is closest to the PC address. By closest we mean
754 that find_pc_sect_symbol returns the symbol with address
755 that is closest and still less than the given PC. */
756 for (tpst
= pst
; tpst
!= NULL
; tpst
= tpst
->next
)
758 if (pc
>= tpst
->textlow
&& pc
< tpst
->texthigh
)
760 struct partial_symbol
*p
;
762 p
= find_pc_sect_psymbol (tpst
, pc
, section
);
764 && SYMBOL_VALUE_ADDRESS (p
)
765 == SYMBOL_VALUE_ADDRESS (msymbol
))
769 /* We found a symbol in this partial symtab which
770 matches (or is closest to) PC, check whether it
771 is closer than our current BEST_PSYM. Since
772 this symbol address is necessarily lower or
773 equal to PC, the symbol closer to PC is the
774 symbol which address is the highest. */
775 /* This way we return the psymtab which contains
776 such best match symbol. This can help in cases
777 where the symbol information/debuginfo is not
778 complete, like for instance on IRIX6 with gcc,
779 where no debug info is emitted for
780 statics. (See also the nodebug.exp
782 if (best_psym
== NULL
783 || SYMBOL_VALUE_ADDRESS (p
)
784 > SYMBOL_VALUE_ADDRESS (best_psym
))
799 /* Find which partial symtab contains PC. Return 0 if none.
800 Backward compatibility, no section */
802 struct partial_symtab
*
803 find_pc_psymtab (CORE_ADDR pc
)
805 return find_pc_sect_psymtab (pc
, find_pc_mapped_section (pc
));
808 /* Find which partial symbol within a psymtab matches PC and SECTION.
809 Return 0 if none. Check all psymtabs if PSYMTAB is 0. */
811 struct partial_symbol
*
812 find_pc_sect_psymbol (struct partial_symtab
*psymtab
, CORE_ADDR pc
,
815 struct partial_symbol
*best
= NULL
, *p
, **pp
;
819 psymtab
= find_pc_sect_psymtab (pc
, section
);
823 /* Cope with programs that start at address 0 */
824 best_pc
= (psymtab
->textlow
!= 0) ? psymtab
->textlow
- 1 : 0;
826 /* Search the global symbols as well as the static symbols, so that
827 find_pc_partial_function doesn't use a minimal symbol and thus
828 cache a bad endaddr. */
829 for (pp
= psymtab
->objfile
->global_psymbols
.list
+ psymtab
->globals_offset
;
830 (pp
- (psymtab
->objfile
->global_psymbols
.list
+ psymtab
->globals_offset
)
831 < psymtab
->n_global_syms
);
835 if (SYMBOL_DOMAIN (p
) == VAR_DOMAIN
836 && SYMBOL_CLASS (p
) == LOC_BLOCK
837 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
838 && (SYMBOL_VALUE_ADDRESS (p
) > best_pc
839 || (psymtab
->textlow
== 0
840 && best_pc
== 0 && SYMBOL_VALUE_ADDRESS (p
) == 0)))
842 if (section
) /* match on a specific section */
844 fixup_psymbol_section (p
, psymtab
->objfile
);
845 if (SYMBOL_BFD_SECTION (p
) != section
)
848 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
853 for (pp
= psymtab
->objfile
->static_psymbols
.list
+ psymtab
->statics_offset
;
854 (pp
- (psymtab
->objfile
->static_psymbols
.list
+ psymtab
->statics_offset
)
855 < psymtab
->n_static_syms
);
859 if (SYMBOL_DOMAIN (p
) == VAR_DOMAIN
860 && SYMBOL_CLASS (p
) == LOC_BLOCK
861 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
862 && (SYMBOL_VALUE_ADDRESS (p
) > best_pc
863 || (psymtab
->textlow
== 0
864 && best_pc
== 0 && SYMBOL_VALUE_ADDRESS (p
) == 0)))
866 if (section
) /* match on a specific section */
868 fixup_psymbol_section (p
, psymtab
->objfile
);
869 if (SYMBOL_BFD_SECTION (p
) != section
)
872 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
880 /* Find which partial symbol within a psymtab matches PC. Return 0 if none.
881 Check all psymtabs if PSYMTAB is 0. Backwards compatibility, no section. */
883 struct partial_symbol
*
884 find_pc_psymbol (struct partial_symtab
*psymtab
, CORE_ADDR pc
)
886 return find_pc_sect_psymbol (psymtab
, pc
, find_pc_mapped_section (pc
));
889 /* Debug symbols usually don't have section information. We need to dig that
890 out of the minimal symbols and stash that in the debug symbol. */
893 fixup_section (struct general_symbol_info
*ginfo
, struct objfile
*objfile
)
895 struct minimal_symbol
*msym
;
896 msym
= lookup_minimal_symbol (ginfo
->name
, NULL
, objfile
);
900 ginfo
->bfd_section
= SYMBOL_BFD_SECTION (msym
);
901 ginfo
->section
= SYMBOL_SECTION (msym
);
905 /* Static, function-local variables do appear in the linker
906 (minimal) symbols, but are frequently given names that won't
907 be found via lookup_minimal_symbol(). E.g., it has been
908 observed in frv-uclinux (ELF) executables that a static,
909 function-local variable named "foo" might appear in the
910 linker symbols as "foo.6" or "foo.3". Thus, there is no
911 point in attempting to extend the lookup-by-name mechanism to
912 handle this case due to the fact that there can be multiple
915 So, instead, search the section table when lookup by name has
916 failed. The ``addr'' and ``endaddr'' fields may have already
917 been relocated. If so, the relocation offset (i.e. the
918 ANOFFSET value) needs to be subtracted from these values when
919 performing the comparison. We unconditionally subtract it,
920 because, when no relocation has been performed, the ANOFFSET
921 value will simply be zero.
923 The address of the symbol whose section we're fixing up HAS
924 NOT BEEN adjusted (relocated) yet. It can't have been since
925 the section isn't yet known and knowing the section is
926 necessary in order to add the correct relocation value. In
927 other words, we wouldn't even be in this function (attempting
928 to compute the section) if it were already known.
930 Note that it is possible to search the minimal symbols
931 (subtracting the relocation value if necessary) to find the
932 matching minimal symbol, but this is overkill and much less
933 efficient. It is not necessary to find the matching minimal
934 symbol, only its section.
936 Note that this technique (of doing a section table search)
937 can fail when unrelocated section addresses overlap. For
938 this reason, we still attempt a lookup by name prior to doing
939 a search of the section table. */
942 struct obj_section
*s
;
944 addr
= ginfo
->value
.address
;
946 ALL_OBJFILE_OSECTIONS (objfile
, s
)
948 int idx
= s
->the_bfd_section
->index
;
949 CORE_ADDR offset
= ANOFFSET (objfile
->section_offsets
, idx
);
951 if (s
->addr
- offset
<= addr
&& addr
< s
->endaddr
- offset
)
953 ginfo
->bfd_section
= s
->the_bfd_section
;
954 ginfo
->section
= idx
;
962 fixup_symbol_section (struct symbol
*sym
, struct objfile
*objfile
)
967 if (SYMBOL_BFD_SECTION (sym
))
970 fixup_section (&sym
->ginfo
, objfile
);
975 struct partial_symbol
*
976 fixup_psymbol_section (struct partial_symbol
*psym
, struct objfile
*objfile
)
981 if (SYMBOL_BFD_SECTION (psym
))
984 fixup_section (&psym
->ginfo
, objfile
);
989 /* Find the definition for a specified symbol name NAME
990 in domain DOMAIN, visible from lexical block BLOCK.
991 Returns the struct symbol pointer, or zero if no symbol is found.
992 If SYMTAB is non-NULL, store the symbol table in which the
993 symbol was found there, or NULL if not found.
994 C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
995 NAME is a field of the current implied argument `this'. If so set
996 *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
997 BLOCK_FOUND is set to the block in which NAME is found (in the case of
998 a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
1000 /* This function has a bunch of loops in it and it would seem to be
1001 attractive to put in some QUIT's (though I'm not really sure
1002 whether it can run long enough to be really important). But there
1003 are a few calls for which it would appear to be bad news to quit
1004 out of here: find_proc_desc in alpha-tdep.c and mips-tdep.c. (Note
1005 that there is C++ code below which can error(), but that probably
1006 doesn't affect these calls since they are looking for a known
1007 variable and thus can probably assume it will never hit the C++
1011 lookup_symbol (const char *name
, const struct block
*block
,
1012 const domain_enum domain
, int *is_a_field_of_this
,
1013 struct symtab
**symtab
)
1015 char *demangled_name
= NULL
;
1016 const char *modified_name
= NULL
;
1017 const char *mangled_name
= NULL
;
1018 int needtofreename
= 0;
1019 struct symbol
*returnval
;
1021 modified_name
= name
;
1023 /* If we are using C++ or Java, demangle the name before doing a lookup, so
1024 we can always binary search. */
1025 if (current_language
->la_language
== language_cplus
)
1027 demangled_name
= cplus_demangle (name
, DMGL_ANSI
| DMGL_PARAMS
);
1030 mangled_name
= name
;
1031 modified_name
= demangled_name
;
1035 else if (current_language
->la_language
== language_java
)
1037 demangled_name
= cplus_demangle (name
,
1038 DMGL_ANSI
| DMGL_PARAMS
| DMGL_JAVA
);
1041 mangled_name
= name
;
1042 modified_name
= demangled_name
;
1047 if (case_sensitivity
== case_sensitive_off
)
1052 len
= strlen (name
);
1053 copy
= (char *) alloca (len
+ 1);
1054 for (i
= 0; i
< len
; i
++)
1055 copy
[i
] = tolower (name
[i
]);
1057 modified_name
= copy
;
1060 returnval
= lookup_symbol_aux (modified_name
, mangled_name
, block
,
1061 domain
, is_a_field_of_this
, symtab
);
1063 xfree (demangled_name
);
1068 /* Behave like lookup_symbol_aux except that NAME is the natural name
1069 of the symbol that we're looking for and, if LINKAGE_NAME is
1070 non-NULL, ensure that the symbol's linkage name matches as
1073 static struct symbol
*
1074 lookup_symbol_aux (const char *name
, const char *linkage_name
,
1075 const struct block
*block
, const domain_enum domain
,
1076 int *is_a_field_of_this
, struct symtab
**symtab
)
1080 /* Make sure we do something sensible with is_a_field_of_this, since
1081 the callers that set this parameter to some non-null value will
1082 certainly use it later and expect it to be either 0 or 1.
1083 If we don't set it, the contents of is_a_field_of_this are
1085 if (is_a_field_of_this
!= NULL
)
1086 *is_a_field_of_this
= 0;
1088 /* Search specified block and its superiors. Don't search
1089 STATIC_BLOCK or GLOBAL_BLOCK. */
1091 sym
= lookup_symbol_aux_local (name
, linkage_name
, block
, domain
,
1096 /* If requested to do so by the caller and if appropriate for the
1097 current language, check to see if NAME is a field of `this'. */
1099 if (current_language
->la_value_of_this
!= NULL
1100 && is_a_field_of_this
!= NULL
)
1102 struct value
*v
= current_language
->la_value_of_this (0);
1104 if (v
&& check_field (v
, name
))
1106 *is_a_field_of_this
= 1;
1113 /* Now do whatever is appropriate for the current language to look
1114 up static and global variables. */
1116 sym
= current_language
->la_lookup_symbol_nonlocal (name
, linkage_name
,
1122 /* Now search all static file-level symbols. Not strictly correct,
1123 but more useful than an error. Do the symtabs first, then check
1124 the psymtabs. If a psymtab indicates the existence of the
1125 desired name as a file-level static, then do psymtab-to-symtab
1126 conversion on the fly and return the found symbol. */
1128 sym
= lookup_symbol_aux_symtabs (STATIC_BLOCK
, name
, linkage_name
,
1133 sym
= lookup_symbol_aux_psymtabs (STATIC_BLOCK
, name
, linkage_name
,
1143 /* Check to see if the symbol is defined in BLOCK or its superiors.
1144 Don't search STATIC_BLOCK or GLOBAL_BLOCK. */
1146 static struct symbol
*
1147 lookup_symbol_aux_local (const char *name
, const char *linkage_name
,
1148 const struct block
*block
,
1149 const domain_enum domain
,
1150 struct symtab
**symtab
)
1153 const struct block
*static_block
= block_static_block (block
);
1155 /* Check if either no block is specified or it's a global block. */
1157 if (static_block
== NULL
)
1160 while (block
!= static_block
)
1162 sym
= lookup_symbol_aux_block (name
, linkage_name
, block
, domain
,
1166 block
= BLOCK_SUPERBLOCK (block
);
1169 /* We've reached the static block without finding a result. */
1174 /* Look up a symbol in a block; if found, locate its symtab, fixup the
1175 symbol, and set block_found appropriately. */
1178 lookup_symbol_aux_block (const char *name
, const char *linkage_name
,
1179 const struct block
*block
,
1180 const domain_enum domain
,
1181 struct symtab
**symtab
)
1184 struct objfile
*objfile
= NULL
;
1185 struct blockvector
*bv
;
1187 struct symtab
*s
= NULL
;
1189 sym
= lookup_block_symbol (block
, name
, linkage_name
, domain
);
1192 block_found
= block
;
1195 /* Search the list of symtabs for one which contains the
1196 address of the start of this block. */
1197 ALL_SYMTABS (objfile
, s
)
1199 bv
= BLOCKVECTOR (s
);
1200 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1201 if (BLOCK_START (b
) <= BLOCK_START (block
)
1202 && BLOCK_END (b
) > BLOCK_START (block
))
1209 return fixup_symbol_section (sym
, objfile
);
1215 /* Check to see if the symbol is defined in one of the symtabs.
1216 BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
1217 depending on whether or not we want to search global symbols or
1220 static struct symbol
*
1221 lookup_symbol_aux_symtabs (int block_index
,
1222 const char *name
, const char *linkage_name
,
1223 const domain_enum domain
,
1224 struct symtab
**symtab
)
1227 struct objfile
*objfile
;
1228 struct blockvector
*bv
;
1229 const struct block
*block
;
1232 ALL_SYMTABS (objfile
, s
)
1234 bv
= BLOCKVECTOR (s
);
1235 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
1236 sym
= lookup_block_symbol (block
, name
, linkage_name
, domain
);
1239 block_found
= block
;
1242 return fixup_symbol_section (sym
, objfile
);
1249 /* Check to see if the symbol is defined in one of the partial
1250 symtabs. BLOCK_INDEX should be either GLOBAL_BLOCK or
1251 STATIC_BLOCK, depending on whether or not we want to search global
1252 symbols or static symbols. */
1254 static struct symbol
*
1255 lookup_symbol_aux_psymtabs (int block_index
, const char *name
,
1256 const char *linkage_name
,
1257 const domain_enum domain
,
1258 struct symtab
**symtab
)
1261 struct objfile
*objfile
;
1262 struct blockvector
*bv
;
1263 const struct block
*block
;
1264 struct partial_symtab
*ps
;
1266 const int psymtab_index
= (block_index
== GLOBAL_BLOCK
? 1 : 0);
1268 ALL_PSYMTABS (objfile
, ps
)
1271 && lookup_partial_symbol (ps
, name
, linkage_name
,
1272 psymtab_index
, domain
))
1274 s
= PSYMTAB_TO_SYMTAB (ps
);
1275 bv
= BLOCKVECTOR (s
);
1276 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
1277 sym
= lookup_block_symbol (block
, name
, linkage_name
, domain
);
1280 /* This shouldn't be necessary, but as a last resort try
1281 looking in the statics even though the psymtab claimed
1282 the symbol was global, or vice-versa. It's possible
1283 that the psymtab gets it wrong in some cases. */
1285 /* FIXME: carlton/2002-09-30: Should we really do that?
1286 If that happens, isn't it likely to be a GDB error, in
1287 which case we should fix the GDB error rather than
1288 silently dealing with it here? So I'd vote for
1289 removing the check for the symbol in the other
1291 block
= BLOCKVECTOR_BLOCK (bv
,
1292 block_index
== GLOBAL_BLOCK
?
1293 STATIC_BLOCK
: GLOBAL_BLOCK
);
1294 sym
= lookup_block_symbol (block
, name
, linkage_name
, domain
);
1296 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>).",
1297 block_index
== GLOBAL_BLOCK
? "global" : "static",
1298 name
, ps
->filename
, name
, name
);
1302 return fixup_symbol_section (sym
, objfile
);
1310 /* Check for the possibility of the symbol being a function or a
1311 mangled variable that is stored in one of the minimal symbol
1312 tables. Eventually, all global symbols might be resolved in this
1315 /* NOTE: carlton/2002-12-05: At one point, this function was part of
1316 lookup_symbol_aux, and what are now 'return' statements within
1317 lookup_symbol_aux_minsyms returned from lookup_symbol_aux, even if
1318 sym was NULL. As far as I can tell, this was basically accidental;
1319 it didn't happen every time that msymbol was non-NULL, but only if
1320 some additional conditions held as well, and it caused problems
1321 with HP-generated symbol tables. */
1323 /* NOTE: carlton/2003-05-14: This function was once used as part of
1324 lookup_symbol. It is currently unnecessary for correctness
1325 reasons, however, and using it doesn't seem to be any faster than
1326 using lookup_symbol_aux_psymtabs, so I'm commenting it out. */
1328 static struct symbol
*
1329 lookup_symbol_aux_minsyms (const char *name
,
1330 const char *linkage_name
,
1331 const domain_enum domain
,
1332 int *is_a_field_of_this
,
1333 struct symtab
**symtab
)
1336 struct blockvector
*bv
;
1337 const struct block
*block
;
1338 struct minimal_symbol
*msymbol
;
1341 if (domain
== VAR_DOMAIN
)
1343 msymbol
= lookup_minimal_symbol (name
, NULL
, NULL
);
1345 if (msymbol
!= NULL
)
1347 /* OK, we found a minimal symbol in spite of not finding any
1348 symbol. There are various possible explanations for
1349 this. One possibility is the symbol exists in code not
1350 compiled -g. Another possibility is that the 'psymtab'
1351 isn't doing its job. A third possibility, related to #2,
1352 is that we were confused by name-mangling. For instance,
1353 maybe the psymtab isn't doing its job because it only
1354 know about demangled names, but we were given a mangled
1357 /* We first use the address in the msymbol to try to locate
1358 the appropriate symtab. Note that find_pc_sect_symtab()
1359 has a side-effect of doing psymtab-to-symtab expansion,
1360 for the found symtab. */
1361 s
= find_pc_sect_symtab (SYMBOL_VALUE_ADDRESS (msymbol
),
1362 SYMBOL_BFD_SECTION (msymbol
));
1365 /* This is a function which has a symtab for its address. */
1366 bv
= BLOCKVECTOR (s
);
1367 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1369 /* This call used to pass `SYMBOL_LINKAGE_NAME (msymbol)' as the
1370 `name' argument to lookup_block_symbol. But the name
1371 of a minimal symbol is always mangled, so that seems
1372 to be clearly the wrong thing to pass as the
1375 lookup_block_symbol (block
, name
, linkage_name
, domain
);
1376 /* We kept static functions in minimal symbol table as well as
1377 in static scope. We want to find them in the symbol table. */
1380 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1381 sym
= lookup_block_symbol (block
, name
,
1382 linkage_name
, domain
);
1385 /* NOTE: carlton/2002-12-04: The following comment was
1386 taken from a time when two versions of this function
1387 were part of the body of lookup_symbol_aux: this
1388 comment was taken from the version of the function
1389 that was #ifdef HPUXHPPA, and the comment was right
1390 before the 'return NULL' part of lookup_symbol_aux.
1391 (Hence the "Fall through and return 0" comment.)
1392 Elena did some digging into the situation for
1393 Fortran, and she reports:
1395 "I asked around (thanks to Jeff Knaggs), and I think
1396 the story for Fortran goes like this:
1398 "Apparently, in older Fortrans, '_' was not part of
1399 the user namespace. g77 attached a final '_' to
1400 procedure names as the exported symbols for linkage
1401 (foo_) , but the symbols went in the debug info just
1402 like 'foo'. The rationale behind this is not
1403 completely clear, and maybe it was done to other
1404 symbols as well, not just procedures." */
1406 /* If we get here with sym == 0, the symbol was
1407 found in the minimal symbol table
1408 but not in the symtab.
1409 Fall through and return 0 to use the msymbol
1410 definition of "foo_".
1411 (Note that outer code generally follows up a call
1412 to this routine with a call to lookup_minimal_symbol(),
1413 so a 0 return means we'll just flow into that other routine).
1415 This happens for Fortran "foo_" symbols,
1416 which are "foo" in the symtab.
1418 This can also happen if "asm" is used to make a
1419 regular symbol but not a debugging symbol, e.g.
1420 asm(".globl _main");
1424 if (symtab
!= NULL
&& sym
!= NULL
)
1426 return fixup_symbol_section (sym
, s
->objfile
);
1435 /* A default version of lookup_symbol_nonlocal for use by languages
1436 that can't think of anything better to do. This implements the C
1440 basic_lookup_symbol_nonlocal (const char *name
,
1441 const char *linkage_name
,
1442 const struct block
*block
,
1443 const domain_enum domain
,
1444 struct symtab
**symtab
)
1448 /* NOTE: carlton/2003-05-19: The comments below were written when
1449 this (or what turned into this) was part of lookup_symbol_aux;
1450 I'm much less worried about these questions now, since these
1451 decisions have turned out well, but I leave these comments here
1454 /* NOTE: carlton/2002-12-05: There is a question as to whether or
1455 not it would be appropriate to search the current global block
1456 here as well. (That's what this code used to do before the
1457 is_a_field_of_this check was moved up.) On the one hand, it's
1458 redundant with the lookup_symbol_aux_symtabs search that happens
1459 next. On the other hand, if decode_line_1 is passed an argument
1460 like filename:var, then the user presumably wants 'var' to be
1461 searched for in filename. On the third hand, there shouldn't be
1462 multiple global variables all of which are named 'var', and it's
1463 not like decode_line_1 has ever restricted its search to only
1464 global variables in a single filename. All in all, only
1465 searching the static block here seems best: it's correct and it's
1468 /* NOTE: carlton/2002-12-05: There's also a possible performance
1469 issue here: if you usually search for global symbols in the
1470 current file, then it would be slightly better to search the
1471 current global block before searching all the symtabs. But there
1472 are other factors that have a much greater effect on performance
1473 than that one, so I don't think we should worry about that for
1476 sym
= lookup_symbol_static (name
, linkage_name
, block
, domain
, symtab
);
1480 return lookup_symbol_global (name
, linkage_name
, domain
, symtab
);
1483 /* Lookup a symbol in the static block associated to BLOCK, if there
1484 is one; do nothing if BLOCK is NULL or a global block. */
1487 lookup_symbol_static (const char *name
,
1488 const char *linkage_name
,
1489 const struct block
*block
,
1490 const domain_enum domain
,
1491 struct symtab
**symtab
)
1493 const struct block
*static_block
= block_static_block (block
);
1495 if (static_block
!= NULL
)
1496 return lookup_symbol_aux_block (name
, linkage_name
, static_block
,
1502 /* Lookup a symbol in all files' global blocks (searching psymtabs if
1506 lookup_symbol_global (const char *name
,
1507 const char *linkage_name
,
1508 const domain_enum domain
,
1509 struct symtab
**symtab
)
1513 sym
= lookup_symbol_aux_symtabs (GLOBAL_BLOCK
, name
, linkage_name
,
1518 return lookup_symbol_aux_psymtabs (GLOBAL_BLOCK
, name
, linkage_name
,
1522 /* Look, in partial_symtab PST, for symbol whose natural name is NAME.
1523 If LINKAGE_NAME is non-NULL, check in addition that the symbol's
1524 linkage name matches it. Check the global symbols if GLOBAL, the
1525 static symbols if not */
1527 struct partial_symbol
*
1528 lookup_partial_symbol (struct partial_symtab
*pst
, const char *name
,
1529 const char *linkage_name
, int global
,
1532 struct partial_symbol
*temp
;
1533 struct partial_symbol
**start
, **psym
;
1534 struct partial_symbol
**top
, **real_top
, **bottom
, **center
;
1535 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
1536 int do_linear_search
= 1;
1543 pst
->objfile
->global_psymbols
.list
+ pst
->globals_offset
:
1544 pst
->objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1546 if (global
) /* This means we can use a binary search. */
1548 do_linear_search
= 0;
1550 /* Binary search. This search is guaranteed to end with center
1551 pointing at the earliest partial symbol whose name might be
1552 correct. At that point *all* partial symbols with an
1553 appropriate name will be checked against the correct
1557 top
= start
+ length
- 1;
1559 while (top
> bottom
)
1561 center
= bottom
+ (top
- bottom
) / 2;
1562 if (!(center
< top
))
1563 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
1564 if (!do_linear_search
1565 && (SYMBOL_LANGUAGE (*center
) == language_java
))
1567 do_linear_search
= 1;
1569 if (strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*center
), name
) >= 0)
1575 bottom
= center
+ 1;
1578 if (!(top
== bottom
))
1579 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
1581 while (top
<= real_top
1582 && (linkage_name
!= NULL
1583 ? strcmp (SYMBOL_LINKAGE_NAME (*top
), linkage_name
) == 0
1584 : SYMBOL_MATCHES_SEARCH_NAME (*top
,name
)))
1586 if (SYMBOL_DOMAIN (*top
) == domain
)
1594 /* Can't use a binary search or else we found during the binary search that
1595 we should also do a linear search. */
1597 if (do_linear_search
)
1599 for (psym
= start
; psym
< start
+ length
; psym
++)
1601 if (domain
== SYMBOL_DOMAIN (*psym
))
1603 if (linkage_name
!= NULL
1604 ? strcmp (SYMBOL_LINKAGE_NAME (*psym
), linkage_name
) == 0
1605 : SYMBOL_MATCHES_SEARCH_NAME (*psym
, name
))
1616 /* Look up a type named NAME in the struct_domain. The type returned
1617 must not be opaque -- i.e., must have at least one field
1621 lookup_transparent_type (const char *name
)
1623 return current_language
->la_lookup_transparent_type (name
);
1626 /* The standard implementation of lookup_transparent_type. This code
1627 was modeled on lookup_symbol -- the parts not relevant to looking
1628 up types were just left out. In particular it's assumed here that
1629 types are available in struct_domain and only at file-static or
1633 basic_lookup_transparent_type (const char *name
)
1636 struct symtab
*s
= NULL
;
1637 struct partial_symtab
*ps
;
1638 struct blockvector
*bv
;
1639 struct objfile
*objfile
;
1640 struct block
*block
;
1642 /* Now search all the global symbols. Do the symtab's first, then
1643 check the psymtab's. If a psymtab indicates the existence
1644 of the desired name as a global, then do psymtab-to-symtab
1645 conversion on the fly and return the found symbol. */
1647 ALL_SYMTABS (objfile
, s
)
1649 bv
= BLOCKVECTOR (s
);
1650 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1651 sym
= lookup_block_symbol (block
, name
, NULL
, STRUCT_DOMAIN
);
1652 if (sym
&& !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1654 return SYMBOL_TYPE (sym
);
1658 ALL_PSYMTABS (objfile
, ps
)
1660 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, NULL
,
1663 s
= PSYMTAB_TO_SYMTAB (ps
);
1664 bv
= BLOCKVECTOR (s
);
1665 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1666 sym
= lookup_block_symbol (block
, name
, NULL
, STRUCT_DOMAIN
);
1669 /* This shouldn't be necessary, but as a last resort
1670 * try looking in the statics even though the psymtab
1671 * claimed the symbol was global. It's possible that
1672 * the psymtab gets it wrong in some cases.
1674 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1675 sym
= lookup_block_symbol (block
, name
, NULL
, STRUCT_DOMAIN
);
1677 error ("Internal: global symbol `%s' found in %s psymtab but not in symtab.\n\
1678 %s may be an inlined function, or may be a template function\n\
1679 (if a template, try specifying an instantiation: %s<type>).",
1680 name
, ps
->filename
, name
, name
);
1682 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1683 return SYMBOL_TYPE (sym
);
1687 /* Now search the static file-level symbols.
1688 Not strictly correct, but more useful than an error.
1689 Do the symtab's first, then
1690 check the psymtab's. If a psymtab indicates the existence
1691 of the desired name as a file-level static, then do psymtab-to-symtab
1692 conversion on the fly and return the found symbol.
1695 ALL_SYMTABS (objfile
, s
)
1697 bv
= BLOCKVECTOR (s
);
1698 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1699 sym
= lookup_block_symbol (block
, name
, NULL
, STRUCT_DOMAIN
);
1700 if (sym
&& !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1702 return SYMBOL_TYPE (sym
);
1706 ALL_PSYMTABS (objfile
, ps
)
1708 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, NULL
, 0, STRUCT_DOMAIN
))
1710 s
= PSYMTAB_TO_SYMTAB (ps
);
1711 bv
= BLOCKVECTOR (s
);
1712 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1713 sym
= lookup_block_symbol (block
, name
, NULL
, STRUCT_DOMAIN
);
1716 /* This shouldn't be necessary, but as a last resort
1717 * try looking in the globals even though the psymtab
1718 * claimed the symbol was static. It's possible that
1719 * the psymtab gets it wrong in some cases.
1721 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1722 sym
= lookup_block_symbol (block
, name
, NULL
, STRUCT_DOMAIN
);
1724 error ("Internal: static symbol `%s' found in %s psymtab but not in symtab.\n\
1725 %s may be an inlined function, or may be a template function\n\
1726 (if a template, try specifying an instantiation: %s<type>).",
1727 name
, ps
->filename
, name
, name
);
1729 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1730 return SYMBOL_TYPE (sym
);
1733 return (struct type
*) 0;
1737 /* Find the psymtab containing main(). */
1738 /* FIXME: What about languages without main() or specially linked
1739 executables that have no main() ? */
1741 struct partial_symtab
*
1742 find_main_psymtab (void)
1744 struct partial_symtab
*pst
;
1745 struct objfile
*objfile
;
1747 ALL_PSYMTABS (objfile
, pst
)
1749 if (lookup_partial_symbol (pst
, main_name (), NULL
, 1, VAR_DOMAIN
))
1757 /* Search BLOCK for symbol NAME in DOMAIN.
1759 Note that if NAME is the demangled form of a C++ symbol, we will fail
1760 to find a match during the binary search of the non-encoded names, but
1761 for now we don't worry about the slight inefficiency of looking for
1762 a match we'll never find, since it will go pretty quick. Once the
1763 binary search terminates, we drop through and do a straight linear
1764 search on the symbols. Each symbol which is marked as being a ObjC/C++
1765 symbol (language_cplus or language_objc set) has both the encoded and
1766 non-encoded names tested for a match.
1768 If LINKAGE_NAME is non-NULL, verify that any symbol we find has this
1769 particular mangled name.
1773 lookup_block_symbol (const struct block
*block
, const char *name
,
1774 const char *linkage_name
,
1775 const domain_enum domain
)
1777 struct dict_iterator iter
;
1780 if (!BLOCK_FUNCTION (block
))
1782 for (sym
= dict_iter_name_first (BLOCK_DICT (block
), name
, &iter
);
1784 sym
= dict_iter_name_next (name
, &iter
))
1786 if (SYMBOL_DOMAIN (sym
) == domain
1787 && (linkage_name
!= NULL
1788 ? strcmp (SYMBOL_LINKAGE_NAME (sym
), linkage_name
) == 0 : 1))
1795 /* Note that parameter symbols do not always show up last in the
1796 list; this loop makes sure to take anything else other than
1797 parameter symbols first; it only uses parameter symbols as a
1798 last resort. Note that this only takes up extra computation
1801 struct symbol
*sym_found
= NULL
;
1803 for (sym
= dict_iter_name_first (BLOCK_DICT (block
), name
, &iter
);
1805 sym
= dict_iter_name_next (name
, &iter
))
1807 if (SYMBOL_DOMAIN (sym
) == domain
1808 && (linkage_name
!= NULL
1809 ? strcmp (SYMBOL_LINKAGE_NAME (sym
), linkage_name
) == 0 : 1))
1812 if (SYMBOL_CLASS (sym
) != LOC_ARG
&&
1813 SYMBOL_CLASS (sym
) != LOC_LOCAL_ARG
&&
1814 SYMBOL_CLASS (sym
) != LOC_REF_ARG
&&
1815 SYMBOL_CLASS (sym
) != LOC_REGPARM
&&
1816 SYMBOL_CLASS (sym
) != LOC_REGPARM_ADDR
&&
1817 SYMBOL_CLASS (sym
) != LOC_BASEREG_ARG
&&
1818 SYMBOL_CLASS (sym
) != LOC_COMPUTED_ARG
)
1824 return (sym_found
); /* Will be NULL if not found. */
1828 /* Find the symtab associated with PC and SECTION. Look through the
1829 psymtabs and read in another symtab if necessary. */
1832 find_pc_sect_symtab (CORE_ADDR pc
, asection
*section
)
1835 struct blockvector
*bv
;
1836 struct symtab
*s
= NULL
;
1837 struct symtab
*best_s
= NULL
;
1838 struct partial_symtab
*ps
;
1839 struct objfile
*objfile
;
1840 CORE_ADDR distance
= 0;
1841 struct minimal_symbol
*msymbol
;
1843 /* If we know that this is not a text address, return failure. This is
1844 necessary because we loop based on the block's high and low code
1845 addresses, which do not include the data ranges, and because
1846 we call find_pc_sect_psymtab which has a similar restriction based
1847 on the partial_symtab's texthigh and textlow. */
1848 msymbol
= lookup_minimal_symbol_by_pc_section (pc
, section
);
1850 && (msymbol
->type
== mst_data
1851 || msymbol
->type
== mst_bss
1852 || msymbol
->type
== mst_abs
1853 || msymbol
->type
== mst_file_data
1854 || msymbol
->type
== mst_file_bss
))
1857 /* Search all symtabs for the one whose file contains our address, and which
1858 is the smallest of all the ones containing the address. This is designed
1859 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
1860 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
1861 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
1863 This happens for native ecoff format, where code from included files
1864 gets its own symtab. The symtab for the included file should have
1865 been read in already via the dependency mechanism.
1866 It might be swifter to create several symtabs with the same name
1867 like xcoff does (I'm not sure).
1869 It also happens for objfiles that have their functions reordered.
1870 For these, the symtab we are looking for is not necessarily read in. */
1872 ALL_SYMTABS (objfile
, s
)
1874 bv
= BLOCKVECTOR (s
);
1875 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1877 if (BLOCK_START (b
) <= pc
1878 && BLOCK_END (b
) > pc
1880 || BLOCK_END (b
) - BLOCK_START (b
) < distance
))
1882 /* For an objfile that has its functions reordered,
1883 find_pc_psymtab will find the proper partial symbol table
1884 and we simply return its corresponding symtab. */
1885 /* In order to better support objfiles that contain both
1886 stabs and coff debugging info, we continue on if a psymtab
1888 if ((objfile
->flags
& OBJF_REORDERED
) && objfile
->psymtabs
)
1890 ps
= find_pc_sect_psymtab (pc
, section
);
1892 return PSYMTAB_TO_SYMTAB (ps
);
1896 struct dict_iterator iter
;
1897 struct symbol
*sym
= NULL
;
1899 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1901 fixup_symbol_section (sym
, objfile
);
1902 if (section
== SYMBOL_BFD_SECTION (sym
))
1906 continue; /* no symbol in this symtab matches section */
1908 distance
= BLOCK_END (b
) - BLOCK_START (b
);
1917 ps
= find_pc_sect_psymtab (pc
, section
);
1921 /* Might want to error() here (in case symtab is corrupt and
1922 will cause a core dump), but maybe we can successfully
1923 continue, so let's not. */
1925 (Internal error: pc 0x%s in read in psymtab, but not in symtab.)\n",
1927 s
= PSYMTAB_TO_SYMTAB (ps
);
1932 /* Find the symtab associated with PC. Look through the psymtabs and
1933 read in another symtab if necessary. Backward compatibility, no section */
1936 find_pc_symtab (CORE_ADDR pc
)
1938 return find_pc_sect_symtab (pc
, find_pc_mapped_section (pc
));
1942 /* Find the source file and line number for a given PC value and SECTION.
1943 Return a structure containing a symtab pointer, a line number,
1944 and a pc range for the entire source line.
1945 The value's .pc field is NOT the specified pc.
1946 NOTCURRENT nonzero means, if specified pc is on a line boundary,
1947 use the line that ends there. Otherwise, in that case, the line
1948 that begins there is used. */
1950 /* The big complication here is that a line may start in one file, and end just
1951 before the start of another file. This usually occurs when you #include
1952 code in the middle of a subroutine. To properly find the end of a line's PC
1953 range, we must search all symtabs associated with this compilation unit, and
1954 find the one whose first PC is closer than that of the next line in this
1957 /* If it's worth the effort, we could be using a binary search. */
1959 struct symtab_and_line
1960 find_pc_sect_line (CORE_ADDR pc
, struct bfd_section
*section
, int notcurrent
)
1963 struct linetable
*l
;
1966 struct linetable_entry
*item
;
1967 struct symtab_and_line val
;
1968 struct blockvector
*bv
;
1969 struct minimal_symbol
*msymbol
;
1970 struct minimal_symbol
*mfunsym
;
1972 /* Info on best line seen so far, and where it starts, and its file. */
1974 struct linetable_entry
*best
= NULL
;
1975 CORE_ADDR best_end
= 0;
1976 struct symtab
*best_symtab
= 0;
1978 /* Store here the first line number
1979 of a file which contains the line at the smallest pc after PC.
1980 If we don't find a line whose range contains PC,
1981 we will use a line one less than this,
1982 with a range from the start of that file to the first line's pc. */
1983 struct linetable_entry
*alt
= NULL
;
1984 struct symtab
*alt_symtab
= 0;
1986 /* Info on best line seen in this file. */
1988 struct linetable_entry
*prev
;
1990 /* If this pc is not from the current frame,
1991 it is the address of the end of a call instruction.
1992 Quite likely that is the start of the following statement.
1993 But what we want is the statement containing the instruction.
1994 Fudge the pc to make sure we get that. */
1996 init_sal (&val
); /* initialize to zeroes */
1998 /* It's tempting to assume that, if we can't find debugging info for
1999 any function enclosing PC, that we shouldn't search for line
2000 number info, either. However, GAS can emit line number info for
2001 assembly files --- very helpful when debugging hand-written
2002 assembly code. In such a case, we'd have no debug info for the
2003 function, but we would have line info. */
2008 /* elz: added this because this function returned the wrong
2009 information if the pc belongs to a stub (import/export)
2010 to call a shlib function. This stub would be anywhere between
2011 two functions in the target, and the line info was erroneously
2012 taken to be the one of the line before the pc.
2014 /* RT: Further explanation:
2016 * We have stubs (trampolines) inserted between procedures.
2018 * Example: "shr1" exists in a shared library, and a "shr1" stub also
2019 * exists in the main image.
2021 * In the minimal symbol table, we have a bunch of symbols
2022 * sorted by start address. The stubs are marked as "trampoline",
2023 * the others appear as text. E.g.:
2025 * Minimal symbol table for main image
2026 * main: code for main (text symbol)
2027 * shr1: stub (trampoline symbol)
2028 * foo: code for foo (text symbol)
2030 * Minimal symbol table for "shr1" image:
2032 * shr1: code for shr1 (text symbol)
2035 * So the code below is trying to detect if we are in the stub
2036 * ("shr1" stub), and if so, find the real code ("shr1" trampoline),
2037 * and if found, do the symbolization from the real-code address
2038 * rather than the stub address.
2040 * Assumptions being made about the minimal symbol table:
2041 * 1. lookup_minimal_symbol_by_pc() will return a trampoline only
2042 * if we're really in the trampoline. If we're beyond it (say
2043 * we're in "foo" in the above example), it'll have a closer
2044 * symbol (the "foo" text symbol for example) and will not
2045 * return the trampoline.
2046 * 2. lookup_minimal_symbol_text() will find a real text symbol
2047 * corresponding to the trampoline, and whose address will
2048 * be different than the trampoline address. I put in a sanity
2049 * check for the address being the same, to avoid an
2050 * infinite recursion.
2052 msymbol
= lookup_minimal_symbol_by_pc (pc
);
2053 if (msymbol
!= NULL
)
2054 if (MSYMBOL_TYPE (msymbol
) == mst_solib_trampoline
)
2056 mfunsym
= lookup_minimal_symbol_text (SYMBOL_LINKAGE_NAME (msymbol
),
2058 if (mfunsym
== NULL
)
2059 /* I eliminated this warning since it is coming out
2060 * in the following situation:
2061 * gdb shmain // test program with shared libraries
2062 * (gdb) break shr1 // function in shared lib
2063 * Warning: In stub for ...
2064 * In the above situation, the shared lib is not loaded yet,
2065 * so of course we can't find the real func/line info,
2066 * but the "break" still works, and the warning is annoying.
2067 * So I commented out the warning. RT */
2068 /* warning ("In stub for %s; unable to find real function/line info", SYMBOL_LINKAGE_NAME (msymbol)) */ ;
2070 else if (SYMBOL_VALUE (mfunsym
) == SYMBOL_VALUE (msymbol
))
2071 /* Avoid infinite recursion */
2072 /* See above comment about why warning is commented out */
2073 /* warning ("In stub for %s; unable to find real function/line info", SYMBOL_LINKAGE_NAME (msymbol)) */ ;
2076 return find_pc_line (SYMBOL_VALUE (mfunsym
), 0);
2080 s
= find_pc_sect_symtab (pc
, section
);
2083 /* if no symbol information, return previous pc */
2090 bv
= BLOCKVECTOR (s
);
2092 /* Look at all the symtabs that share this blockvector.
2093 They all have the same apriori range, that we found was right;
2094 but they have different line tables. */
2096 for (; s
&& BLOCKVECTOR (s
) == bv
; s
= s
->next
)
2098 /* Find the best line in this symtab. */
2105 /* I think len can be zero if the symtab lacks line numbers
2106 (e.g. gcc -g1). (Either that or the LINETABLE is NULL;
2107 I'm not sure which, and maybe it depends on the symbol
2113 item
= l
->item
; /* Get first line info */
2115 /* Is this file's first line closer than the first lines of other files?
2116 If so, record this file, and its first line, as best alternate. */
2117 if (item
->pc
> pc
&& (!alt
|| item
->pc
< alt
->pc
))
2123 for (i
= 0; i
< len
; i
++, item
++)
2125 /* Leave prev pointing to the linetable entry for the last line
2126 that started at or before PC. */
2133 /* At this point, prev points at the line whose start addr is <= pc, and
2134 item points at the next line. If we ran off the end of the linetable
2135 (pc >= start of the last line), then prev == item. If pc < start of
2136 the first line, prev will not be set. */
2138 /* Is this file's best line closer than the best in the other files?
2139 If so, record this file, and its best line, as best so far. Don't
2140 save prev if it represents the end of a function (i.e. line number
2141 0) instead of a real line. */
2143 if (prev
&& prev
->line
&& (!best
|| prev
->pc
> best
->pc
))
2148 /* Discard BEST_END if it's before the PC of the current BEST. */
2149 if (best_end
<= best
->pc
)
2153 /* If another line (denoted by ITEM) is in the linetable and its
2154 PC is after BEST's PC, but before the current BEST_END, then
2155 use ITEM's PC as the new best_end. */
2156 if (best
&& i
< len
&& item
->pc
> best
->pc
2157 && (best_end
== 0 || best_end
> item
->pc
))
2158 best_end
= item
->pc
;
2164 { /* If we didn't find any line # info, just
2170 val
.symtab
= alt_symtab
;
2171 val
.line
= alt
->line
- 1;
2173 /* Don't return line 0, that means that we didn't find the line. */
2177 val
.pc
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
2181 else if (best
->line
== 0)
2183 /* If our best fit is in a range of PC's for which no line
2184 number info is available (line number is zero) then we didn't
2185 find any valid line information. */
2190 val
.symtab
= best_symtab
;
2191 val
.line
= best
->line
;
2193 if (best_end
&& (!alt
|| best_end
< alt
->pc
))
2198 val
.end
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
2200 val
.section
= section
;
2204 /* Backward compatibility (no section) */
2206 struct symtab_and_line
2207 find_pc_line (CORE_ADDR pc
, int notcurrent
)
2211 section
= find_pc_overlay (pc
);
2212 if (pc_in_unmapped_range (pc
, section
))
2213 pc
= overlay_mapped_address (pc
, section
);
2214 return find_pc_sect_line (pc
, section
, notcurrent
);
2217 /* Find line number LINE in any symtab whose name is the same as
2220 If found, return the symtab that contains the linetable in which it was
2221 found, set *INDEX to the index in the linetable of the best entry
2222 found, and set *EXACT_MATCH nonzero if the value returned is an
2225 If not found, return NULL. */
2228 find_line_symtab (struct symtab
*symtab
, int line
, int *index
, int *exact_match
)
2232 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
2236 struct linetable
*best_linetable
;
2237 struct symtab
*best_symtab
;
2239 /* First try looking it up in the given symtab. */
2240 best_linetable
= LINETABLE (symtab
);
2241 best_symtab
= symtab
;
2242 best_index
= find_line_common (best_linetable
, line
, &exact
);
2243 if (best_index
< 0 || !exact
)
2245 /* Didn't find an exact match. So we better keep looking for
2246 another symtab with the same name. In the case of xcoff,
2247 multiple csects for one source file (produced by IBM's FORTRAN
2248 compiler) produce multiple symtabs (this is unavoidable
2249 assuming csects can be at arbitrary places in memory and that
2250 the GLOBAL_BLOCK of a symtab has a begin and end address). */
2252 /* BEST is the smallest linenumber > LINE so far seen,
2253 or 0 if none has been seen so far.
2254 BEST_INDEX and BEST_LINETABLE identify the item for it. */
2257 struct objfile
*objfile
;
2260 if (best_index
>= 0)
2261 best
= best_linetable
->item
[best_index
].line
;
2265 ALL_SYMTABS (objfile
, s
)
2267 struct linetable
*l
;
2270 if (strcmp (symtab
->filename
, s
->filename
) != 0)
2273 ind
= find_line_common (l
, line
, &exact
);
2283 if (best
== 0 || l
->item
[ind
].line
< best
)
2285 best
= l
->item
[ind
].line
;
2298 *index
= best_index
;
2300 *exact_match
= exact
;
2305 /* Set the PC value for a given source file and line number and return true.
2306 Returns zero for invalid line number (and sets the PC to 0).
2307 The source file is specified with a struct symtab. */
2310 find_line_pc (struct symtab
*symtab
, int line
, CORE_ADDR
*pc
)
2312 struct linetable
*l
;
2319 symtab
= find_line_symtab (symtab
, line
, &ind
, NULL
);
2322 l
= LINETABLE (symtab
);
2323 *pc
= l
->item
[ind
].pc
;
2330 /* Find the range of pc values in a line.
2331 Store the starting pc of the line into *STARTPTR
2332 and the ending pc (start of next line) into *ENDPTR.
2333 Returns 1 to indicate success.
2334 Returns 0 if could not find the specified line. */
2337 find_line_pc_range (struct symtab_and_line sal
, CORE_ADDR
*startptr
,
2340 CORE_ADDR startaddr
;
2341 struct symtab_and_line found_sal
;
2344 if (startaddr
== 0 && !find_line_pc (sal
.symtab
, sal
.line
, &startaddr
))
2347 /* This whole function is based on address. For example, if line 10 has
2348 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
2349 "info line *0x123" should say the line goes from 0x100 to 0x200
2350 and "info line *0x355" should say the line goes from 0x300 to 0x400.
2351 This also insures that we never give a range like "starts at 0x134
2352 and ends at 0x12c". */
2354 found_sal
= find_pc_sect_line (startaddr
, sal
.section
, 0);
2355 if (found_sal
.line
!= sal
.line
)
2357 /* The specified line (sal) has zero bytes. */
2358 *startptr
= found_sal
.pc
;
2359 *endptr
= found_sal
.pc
;
2363 *startptr
= found_sal
.pc
;
2364 *endptr
= found_sal
.end
;
2369 /* Given a line table and a line number, return the index into the line
2370 table for the pc of the nearest line whose number is >= the specified one.
2371 Return -1 if none is found. The value is >= 0 if it is an index.
2373 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
2376 find_line_common (struct linetable
*l
, int lineno
,
2382 /* BEST is the smallest linenumber > LINENO so far seen,
2383 or 0 if none has been seen so far.
2384 BEST_INDEX identifies the item for it. */
2386 int best_index
= -1;
2395 for (i
= 0; i
< len
; i
++)
2397 struct linetable_entry
*item
= &(l
->item
[i
]);
2399 if (item
->line
== lineno
)
2401 /* Return the first (lowest address) entry which matches. */
2406 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
2413 /* If we got here, we didn't get an exact match. */
2420 find_pc_line_pc_range (CORE_ADDR pc
, CORE_ADDR
*startptr
, CORE_ADDR
*endptr
)
2422 struct symtab_and_line sal
;
2423 sal
= find_pc_line (pc
, 0);
2426 return sal
.symtab
!= 0;
2429 /* Given a function symbol SYM, find the symtab and line for the start
2431 If the argument FUNFIRSTLINE is nonzero, we want the first line
2432 of real code inside the function. */
2434 struct symtab_and_line
2435 find_function_start_sal (struct symbol
*sym
, int funfirstline
)
2438 struct symtab_and_line sal
;
2440 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
2441 fixup_symbol_section (sym
, NULL
);
2443 { /* skip "first line" of function (which is actually its prologue) */
2444 asection
*section
= SYMBOL_BFD_SECTION (sym
);
2445 /* If function is in an unmapped overlay, use its unmapped LMA
2446 address, so that SKIP_PROLOGUE has something unique to work on */
2447 if (section_is_overlay (section
) &&
2448 !section_is_mapped (section
))
2449 pc
= overlay_unmapped_address (pc
, section
);
2451 pc
+= DEPRECATED_FUNCTION_START_OFFSET
;
2452 pc
= SKIP_PROLOGUE (pc
);
2454 /* For overlays, map pc back into its mapped VMA range */
2455 pc
= overlay_mapped_address (pc
, section
);
2457 sal
= find_pc_sect_line (pc
, SYMBOL_BFD_SECTION (sym
), 0);
2459 /* Check if SKIP_PROLOGUE left us in mid-line, and the next
2460 line is still part of the same function. */
2462 && BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) <= sal
.end
2463 && sal
.end
< BLOCK_END (SYMBOL_BLOCK_VALUE (sym
)))
2465 /* First pc of next line */
2467 /* Recalculate the line number (might not be N+1). */
2468 sal
= find_pc_sect_line (pc
, SYMBOL_BFD_SECTION (sym
), 0);
2475 /* If P is of the form "operator[ \t]+..." where `...' is
2476 some legitimate operator text, return a pointer to the
2477 beginning of the substring of the operator text.
2478 Otherwise, return "". */
2480 operator_chars (char *p
, char **end
)
2483 if (strncmp (p
, "operator", 8))
2487 /* Don't get faked out by `operator' being part of a longer
2489 if (isalpha (*p
) || *p
== '_' || *p
== '$' || *p
== '\0')
2492 /* Allow some whitespace between `operator' and the operator symbol. */
2493 while (*p
== ' ' || *p
== '\t')
2496 /* Recognize 'operator TYPENAME'. */
2498 if (isalpha (*p
) || *p
== '_' || *p
== '$')
2501 while (isalnum (*q
) || *q
== '_' || *q
== '$')
2510 case '\\': /* regexp quoting */
2513 if (p
[2] == '=') /* 'operator\*=' */
2515 else /* 'operator\*' */
2519 else if (p
[1] == '[')
2522 error ("mismatched quoting on brackets, try 'operator\\[\\]'");
2523 else if (p
[2] == '\\' && p
[3] == ']')
2525 *end
= p
+ 4; /* 'operator\[\]' */
2529 error ("nothing is allowed between '[' and ']'");
2533 /* Gratuitous qoute: skip it and move on. */
2555 if (p
[0] == '-' && p
[1] == '>')
2557 /* Struct pointer member operator 'operator->'. */
2560 *end
= p
+ 3; /* 'operator->*' */
2563 else if (p
[2] == '\\')
2565 *end
= p
+ 4; /* Hopefully 'operator->\*' */
2570 *end
= p
+ 2; /* 'operator->' */
2574 if (p
[1] == '=' || p
[1] == p
[0])
2585 error ("`operator ()' must be specified without whitespace in `()'");
2590 error ("`operator ?:' must be specified without whitespace in `?:'");
2595 error ("`operator []' must be specified without whitespace in `[]'");
2599 error ("`operator %s' not supported", p
);
2608 /* If FILE is not already in the table of files, return zero;
2609 otherwise return non-zero. Optionally add FILE to the table if ADD
2610 is non-zero. If *FIRST is non-zero, forget the old table
2613 filename_seen (const char *file
, int add
, int *first
)
2615 /* Table of files seen so far. */
2616 static const char **tab
= NULL
;
2617 /* Allocated size of tab in elements.
2618 Start with one 256-byte block (when using GNU malloc.c).
2619 24 is the malloc overhead when range checking is in effect. */
2620 static int tab_alloc_size
= (256 - 24) / sizeof (char *);
2621 /* Current size of tab in elements. */
2622 static int tab_cur_size
;
2628 tab
= (const char **) xmalloc (tab_alloc_size
* sizeof (*tab
));
2632 /* Is FILE in tab? */
2633 for (p
= tab
; p
< tab
+ tab_cur_size
; p
++)
2634 if (strcmp (*p
, file
) == 0)
2637 /* No; maybe add it to tab. */
2640 if (tab_cur_size
== tab_alloc_size
)
2642 tab_alloc_size
*= 2;
2643 tab
= (const char **) xrealloc ((char *) tab
,
2644 tab_alloc_size
* sizeof (*tab
));
2646 tab
[tab_cur_size
++] = file
;
2652 /* Slave routine for sources_info. Force line breaks at ,'s.
2653 NAME is the name to print and *FIRST is nonzero if this is the first
2654 name printed. Set *FIRST to zero. */
2656 output_source_filename (const char *name
, int *first
)
2658 /* Since a single source file can result in several partial symbol
2659 tables, we need to avoid printing it more than once. Note: if
2660 some of the psymtabs are read in and some are not, it gets
2661 printed both under "Source files for which symbols have been
2662 read" and "Source files for which symbols will be read in on
2663 demand". I consider this a reasonable way to deal with the
2664 situation. I'm not sure whether this can also happen for
2665 symtabs; it doesn't hurt to check. */
2667 /* Was NAME already seen? */
2668 if (filename_seen (name
, 1, first
))
2670 /* Yes; don't print it again. */
2673 /* No; print it and reset *FIRST. */
2680 printf_filtered (", ");
2684 fputs_filtered (name
, gdb_stdout
);
2688 sources_info (char *ignore
, int from_tty
)
2691 struct partial_symtab
*ps
;
2692 struct objfile
*objfile
;
2695 if (!have_full_symbols () && !have_partial_symbols ())
2697 error ("No symbol table is loaded. Use the \"file\" command.");
2700 printf_filtered ("Source files for which symbols have been read in:\n\n");
2703 ALL_SYMTABS (objfile
, s
)
2705 const char *fullname
= symtab_to_fullname (s
);
2706 output_source_filename (fullname
? fullname
: s
->filename
, &first
);
2708 printf_filtered ("\n\n");
2710 printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
2713 ALL_PSYMTABS (objfile
, ps
)
2717 const char *fullname
= psymtab_to_fullname (ps
);
2718 output_source_filename (fullname
? fullname
: ps
->filename
, &first
);
2721 printf_filtered ("\n");
2725 file_matches (char *file
, char *files
[], int nfiles
)
2729 if (file
!= NULL
&& nfiles
!= 0)
2731 for (i
= 0; i
< nfiles
; i
++)
2733 if (strcmp (files
[i
], lbasename (file
)) == 0)
2737 else if (nfiles
== 0)
2742 /* Free any memory associated with a search. */
2744 free_search_symbols (struct symbol_search
*symbols
)
2746 struct symbol_search
*p
;
2747 struct symbol_search
*next
;
2749 for (p
= symbols
; p
!= NULL
; p
= next
)
2757 do_free_search_symbols_cleanup (void *symbols
)
2759 free_search_symbols (symbols
);
2763 make_cleanup_free_search_symbols (struct symbol_search
*symbols
)
2765 return make_cleanup (do_free_search_symbols_cleanup
, symbols
);
2768 /* Helper function for sort_search_symbols and qsort. Can only
2769 sort symbols, not minimal symbols. */
2771 compare_search_syms (const void *sa
, const void *sb
)
2773 struct symbol_search
**sym_a
= (struct symbol_search
**) sa
;
2774 struct symbol_search
**sym_b
= (struct symbol_search
**) sb
;
2776 return strcmp (SYMBOL_PRINT_NAME ((*sym_a
)->symbol
),
2777 SYMBOL_PRINT_NAME ((*sym_b
)->symbol
));
2780 /* Sort the ``nfound'' symbols in the list after prevtail. Leave
2781 prevtail where it is, but update its next pointer to point to
2782 the first of the sorted symbols. */
2783 static struct symbol_search
*
2784 sort_search_symbols (struct symbol_search
*prevtail
, int nfound
)
2786 struct symbol_search
**symbols
, *symp
, *old_next
;
2789 symbols
= (struct symbol_search
**) xmalloc (sizeof (struct symbol_search
*)
2791 symp
= prevtail
->next
;
2792 for (i
= 0; i
< nfound
; i
++)
2797 /* Generally NULL. */
2800 qsort (symbols
, nfound
, sizeof (struct symbol_search
*),
2801 compare_search_syms
);
2804 for (i
= 0; i
< nfound
; i
++)
2806 symp
->next
= symbols
[i
];
2809 symp
->next
= old_next
;
2815 /* Search the symbol table for matches to the regular expression REGEXP,
2816 returning the results in *MATCHES.
2818 Only symbols of KIND are searched:
2819 FUNCTIONS_DOMAIN - search all functions
2820 TYPES_DOMAIN - search all type names
2821 METHODS_DOMAIN - search all methods NOT IMPLEMENTED
2822 VARIABLES_DOMAIN - search all symbols, excluding functions, type names,
2823 and constants (enums)
2825 free_search_symbols should be called when *MATCHES is no longer needed.
2827 The results are sorted locally; each symtab's global and static blocks are
2828 separately alphabetized.
2831 search_symbols (char *regexp
, domain_enum kind
, int nfiles
, char *files
[],
2832 struct symbol_search
**matches
)
2835 struct partial_symtab
*ps
;
2836 struct blockvector
*bv
;
2837 struct blockvector
*prev_bv
= 0;
2840 struct dict_iterator iter
;
2842 struct partial_symbol
**psym
;
2843 struct objfile
*objfile
;
2844 struct minimal_symbol
*msymbol
;
2847 static enum minimal_symbol_type types
[]
2849 {mst_data
, mst_text
, mst_abs
, mst_unknown
};
2850 static enum minimal_symbol_type types2
[]
2852 {mst_bss
, mst_file_text
, mst_abs
, mst_unknown
};
2853 static enum minimal_symbol_type types3
[]
2855 {mst_file_data
, mst_solib_trampoline
, mst_abs
, mst_unknown
};
2856 static enum minimal_symbol_type types4
[]
2858 {mst_file_bss
, mst_text
, mst_abs
, mst_unknown
};
2859 enum minimal_symbol_type ourtype
;
2860 enum minimal_symbol_type ourtype2
;
2861 enum minimal_symbol_type ourtype3
;
2862 enum minimal_symbol_type ourtype4
;
2863 struct symbol_search
*sr
;
2864 struct symbol_search
*psr
;
2865 struct symbol_search
*tail
;
2866 struct cleanup
*old_chain
= NULL
;
2868 if (kind
< VARIABLES_DOMAIN
)
2869 error ("must search on specific domain");
2871 ourtype
= types
[(int) (kind
- VARIABLES_DOMAIN
)];
2872 ourtype2
= types2
[(int) (kind
- VARIABLES_DOMAIN
)];
2873 ourtype3
= types3
[(int) (kind
- VARIABLES_DOMAIN
)];
2874 ourtype4
= types4
[(int) (kind
- VARIABLES_DOMAIN
)];
2876 sr
= *matches
= NULL
;
2881 /* Make sure spacing is right for C++ operators.
2882 This is just a courtesy to make the matching less sensitive
2883 to how many spaces the user leaves between 'operator'
2884 and <TYPENAME> or <OPERATOR>. */
2886 char *opname
= operator_chars (regexp
, &opend
);
2889 int fix
= -1; /* -1 means ok; otherwise number of spaces needed. */
2890 if (isalpha (*opname
) || *opname
== '_' || *opname
== '$')
2892 /* There should 1 space between 'operator' and 'TYPENAME'. */
2893 if (opname
[-1] != ' ' || opname
[-2] == ' ')
2898 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
2899 if (opname
[-1] == ' ')
2902 /* If wrong number of spaces, fix it. */
2905 char *tmp
= (char *) alloca (8 + fix
+ strlen (opname
) + 1);
2906 sprintf (tmp
, "operator%.*s%s", fix
, " ", opname
);
2911 if (0 != (val
= re_comp (regexp
)))
2912 error ("Invalid regexp (%s): %s", val
, regexp
);
2915 /* Search through the partial symtabs *first* for all symbols
2916 matching the regexp. That way we don't have to reproduce all of
2917 the machinery below. */
2919 ALL_PSYMTABS (objfile
, ps
)
2921 struct partial_symbol
**bound
, **gbound
, **sbound
;
2927 gbound
= objfile
->global_psymbols
.list
+ ps
->globals_offset
+ ps
->n_global_syms
;
2928 sbound
= objfile
->static_psymbols
.list
+ ps
->statics_offset
+ ps
->n_static_syms
;
2931 /* Go through all of the symbols stored in a partial
2932 symtab in one loop. */
2933 psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2938 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
2940 psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
2951 /* If it would match (logic taken from loop below)
2952 load the file and go on to the next one */
2953 if (file_matches (ps
->filename
, files
, nfiles
)
2955 || re_exec (SYMBOL_NATURAL_NAME (*psym
)) != 0)
2956 && ((kind
== VARIABLES_DOMAIN
&& SYMBOL_CLASS (*psym
) != LOC_TYPEDEF
2957 && SYMBOL_CLASS (*psym
) != LOC_BLOCK
)
2958 || (kind
== FUNCTIONS_DOMAIN
&& SYMBOL_CLASS (*psym
) == LOC_BLOCK
)
2959 || (kind
== TYPES_DOMAIN
&& SYMBOL_CLASS (*psym
) == LOC_TYPEDEF
)
2960 || (kind
== METHODS_DOMAIN
&& SYMBOL_CLASS (*psym
) == LOC_BLOCK
))))
2962 PSYMTAB_TO_SYMTAB (ps
);
2970 /* Here, we search through the minimal symbol tables for functions
2971 and variables that match, and force their symbols to be read.
2972 This is in particular necessary for demangled variable names,
2973 which are no longer put into the partial symbol tables.
2974 The symbol will then be found during the scan of symtabs below.
2976 For functions, find_pc_symtab should succeed if we have debug info
2977 for the function, for variables we have to call lookup_symbol
2978 to determine if the variable has debug info.
2979 If the lookup fails, set found_misc so that we will rescan to print
2980 any matching symbols without debug info.
2983 if (nfiles
== 0 && (kind
== VARIABLES_DOMAIN
|| kind
== FUNCTIONS_DOMAIN
))
2985 ALL_MSYMBOLS (objfile
, msymbol
)
2987 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
2988 MSYMBOL_TYPE (msymbol
) == ourtype2
||
2989 MSYMBOL_TYPE (msymbol
) == ourtype3
||
2990 MSYMBOL_TYPE (msymbol
) == ourtype4
)
2993 || re_exec (SYMBOL_NATURAL_NAME (msymbol
)) != 0)
2995 if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
)))
2997 /* FIXME: carlton/2003-02-04: Given that the
2998 semantics of lookup_symbol keeps on changing
2999 slightly, it would be a nice idea if we had a
3000 function lookup_symbol_minsym that found the
3001 symbol associated to a given minimal symbol (if
3003 if (kind
== FUNCTIONS_DOMAIN
3004 || lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol
),
3005 (struct block
*) NULL
,
3007 0, (struct symtab
**) NULL
) == NULL
)
3015 ALL_SYMTABS (objfile
, s
)
3017 bv
= BLOCKVECTOR (s
);
3018 /* Often many files share a blockvector.
3019 Scan each blockvector only once so that
3020 we don't get every symbol many times.
3021 It happens that the first symtab in the list
3022 for any given blockvector is the main file. */
3024 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
3026 struct symbol_search
*prevtail
= tail
;
3028 b
= BLOCKVECTOR_BLOCK (bv
, i
);
3029 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
3032 if (file_matches (s
->filename
, files
, nfiles
)
3034 || re_exec (SYMBOL_NATURAL_NAME (sym
)) != 0)
3035 && ((kind
== VARIABLES_DOMAIN
&& SYMBOL_CLASS (sym
) != LOC_TYPEDEF
3036 && SYMBOL_CLASS (sym
) != LOC_BLOCK
3037 && SYMBOL_CLASS (sym
) != LOC_CONST
)
3038 || (kind
== FUNCTIONS_DOMAIN
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
3039 || (kind
== TYPES_DOMAIN
&& SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
3040 || (kind
== METHODS_DOMAIN
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
))))
3043 psr
= (struct symbol_search
*) xmalloc (sizeof (struct symbol_search
));
3047 psr
->msymbol
= NULL
;
3059 if (prevtail
== NULL
)
3061 struct symbol_search dummy
;
3064 tail
= sort_search_symbols (&dummy
, nfound
);
3067 old_chain
= make_cleanup_free_search_symbols (sr
);
3070 tail
= sort_search_symbols (prevtail
, nfound
);
3076 /* If there are no eyes, avoid all contact. I mean, if there are
3077 no debug symbols, then print directly from the msymbol_vector. */
3079 if (found_misc
|| kind
!= FUNCTIONS_DOMAIN
)
3081 ALL_MSYMBOLS (objfile
, msymbol
)
3083 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
3084 MSYMBOL_TYPE (msymbol
) == ourtype2
||
3085 MSYMBOL_TYPE (msymbol
) == ourtype3
||
3086 MSYMBOL_TYPE (msymbol
) == ourtype4
)
3089 || re_exec (SYMBOL_NATURAL_NAME (msymbol
)) != 0)
3091 /* Functions: Look up by address. */
3092 if (kind
!= FUNCTIONS_DOMAIN
||
3093 (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
))))
3095 /* Variables/Absolutes: Look up by name */
3096 if (lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol
),
3097 (struct block
*) NULL
, VAR_DOMAIN
,
3098 0, (struct symtab
**) NULL
) == NULL
)
3101 psr
= (struct symbol_search
*) xmalloc (sizeof (struct symbol_search
));
3103 psr
->msymbol
= msymbol
;
3110 old_chain
= make_cleanup_free_search_symbols (sr
);
3124 discard_cleanups (old_chain
);
3127 /* Helper function for symtab_symbol_info, this function uses
3128 the data returned from search_symbols() to print information
3129 regarding the match to gdb_stdout.
3132 print_symbol_info (domain_enum kind
, struct symtab
*s
, struct symbol
*sym
,
3133 int block
, char *last
)
3135 if (last
== NULL
|| strcmp (last
, s
->filename
) != 0)
3137 fputs_filtered ("\nFile ", gdb_stdout
);
3138 fputs_filtered (s
->filename
, gdb_stdout
);
3139 fputs_filtered (":\n", gdb_stdout
);
3142 if (kind
!= TYPES_DOMAIN
&& block
== STATIC_BLOCK
)
3143 printf_filtered ("static ");
3145 /* Typedef that is not a C++ class */
3146 if (kind
== TYPES_DOMAIN
3147 && SYMBOL_DOMAIN (sym
) != STRUCT_DOMAIN
)
3148 typedef_print (SYMBOL_TYPE (sym
), sym
, gdb_stdout
);
3149 /* variable, func, or typedef-that-is-c++-class */
3150 else if (kind
< TYPES_DOMAIN
||
3151 (kind
== TYPES_DOMAIN
&&
3152 SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
))
3154 type_print (SYMBOL_TYPE (sym
),
3155 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
3156 ? "" : SYMBOL_PRINT_NAME (sym
)),
3159 printf_filtered (";\n");
3163 /* This help function for symtab_symbol_info() prints information
3164 for non-debugging symbols to gdb_stdout.
3167 print_msymbol_info (struct minimal_symbol
*msymbol
)
3171 if (TARGET_ADDR_BIT
<= 32)
3172 tmp
= hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol
)
3173 & (CORE_ADDR
) 0xffffffff,
3176 tmp
= hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol
),
3178 printf_filtered ("%s %s\n",
3179 tmp
, SYMBOL_PRINT_NAME (msymbol
));
3182 /* This is the guts of the commands "info functions", "info types", and
3183 "info variables". It calls search_symbols to find all matches and then
3184 print_[m]symbol_info to print out some useful information about the
3188 symtab_symbol_info (char *regexp
, domain_enum kind
, int from_tty
)
3190 static char *classnames
[]
3192 {"variable", "function", "type", "method"};
3193 struct symbol_search
*symbols
;
3194 struct symbol_search
*p
;
3195 struct cleanup
*old_chain
;
3196 char *last_filename
= NULL
;
3199 /* must make sure that if we're interrupted, symbols gets freed */
3200 search_symbols (regexp
, kind
, 0, (char **) NULL
, &symbols
);
3201 old_chain
= make_cleanup_free_search_symbols (symbols
);
3203 printf_filtered (regexp
3204 ? "All %ss matching regular expression \"%s\":\n"
3205 : "All defined %ss:\n",
3206 classnames
[(int) (kind
- VARIABLES_DOMAIN
)], regexp
);
3208 for (p
= symbols
; p
!= NULL
; p
= p
->next
)
3212 if (p
->msymbol
!= NULL
)
3216 printf_filtered ("\nNon-debugging symbols:\n");
3219 print_msymbol_info (p
->msymbol
);
3223 print_symbol_info (kind
,
3228 last_filename
= p
->symtab
->filename
;
3232 do_cleanups (old_chain
);
3236 variables_info (char *regexp
, int from_tty
)
3238 symtab_symbol_info (regexp
, VARIABLES_DOMAIN
, from_tty
);
3242 functions_info (char *regexp
, int from_tty
)
3244 symtab_symbol_info (regexp
, FUNCTIONS_DOMAIN
, from_tty
);
3249 types_info (char *regexp
, int from_tty
)
3251 symtab_symbol_info (regexp
, TYPES_DOMAIN
, from_tty
);
3254 /* Breakpoint all functions matching regular expression. */
3257 rbreak_command_wrapper (char *regexp
, int from_tty
)
3259 rbreak_command (regexp
, from_tty
);
3263 rbreak_command (char *regexp
, int from_tty
)
3265 struct symbol_search
*ss
;
3266 struct symbol_search
*p
;
3267 struct cleanup
*old_chain
;
3269 search_symbols (regexp
, FUNCTIONS_DOMAIN
, 0, (char **) NULL
, &ss
);
3270 old_chain
= make_cleanup_free_search_symbols (ss
);
3272 for (p
= ss
; p
!= NULL
; p
= p
->next
)
3274 if (p
->msymbol
== NULL
)
3276 char *string
= alloca (strlen (p
->symtab
->filename
)
3277 + strlen (SYMBOL_LINKAGE_NAME (p
->symbol
))
3279 strcpy (string
, p
->symtab
->filename
);
3280 strcat (string
, ":'");
3281 strcat (string
, SYMBOL_LINKAGE_NAME (p
->symbol
));
3282 strcat (string
, "'");
3283 break_command (string
, from_tty
);
3284 print_symbol_info (FUNCTIONS_DOMAIN
,
3288 p
->symtab
->filename
);
3292 break_command (SYMBOL_LINKAGE_NAME (p
->msymbol
), from_tty
);
3293 printf_filtered ("<function, no debug info> %s;\n",
3294 SYMBOL_PRINT_NAME (p
->msymbol
));
3298 do_cleanups (old_chain
);
3302 /* Helper routine for make_symbol_completion_list. */
3304 static int return_val_size
;
3305 static int return_val_index
;
3306 static char **return_val
;
3308 #define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
3309 completion_list_add_name \
3310 (SYMBOL_NATURAL_NAME (symbol), (sym_text), (len), (text), (word))
3312 /* Test to see if the symbol specified by SYMNAME (which is already
3313 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
3314 characters. If so, add it to the current completion list. */
3317 completion_list_add_name (char *symname
, char *sym_text
, int sym_text_len
,
3318 char *text
, char *word
)
3323 /* clip symbols that cannot match */
3325 if (strncmp (symname
, sym_text
, sym_text_len
) != 0)
3330 /* We have a match for a completion, so add SYMNAME to the current list
3331 of matches. Note that the name is moved to freshly malloc'd space. */
3335 if (word
== sym_text
)
3337 new = xmalloc (strlen (symname
) + 5);
3338 strcpy (new, symname
);
3340 else if (word
> sym_text
)
3342 /* Return some portion of symname. */
3343 new = xmalloc (strlen (symname
) + 5);
3344 strcpy (new, symname
+ (word
- sym_text
));
3348 /* Return some of SYM_TEXT plus symname. */
3349 new = xmalloc (strlen (symname
) + (sym_text
- word
) + 5);
3350 strncpy (new, word
, sym_text
- word
);
3351 new[sym_text
- word
] = '\0';
3352 strcat (new, symname
);
3355 if (return_val_index
+ 3 > return_val_size
)
3357 newsize
= (return_val_size
*= 2) * sizeof (char *);
3358 return_val
= (char **) xrealloc ((char *) return_val
, newsize
);
3360 return_val
[return_val_index
++] = new;
3361 return_val
[return_val_index
] = NULL
;
3365 /* ObjC: In case we are completing on a selector, look as the msymbol
3366 again and feed all the selectors into the mill. */
3369 completion_list_objc_symbol (struct minimal_symbol
*msymbol
, char *sym_text
,
3370 int sym_text_len
, char *text
, char *word
)
3372 static char *tmp
= NULL
;
3373 static unsigned int tmplen
= 0;
3375 char *method
, *category
, *selector
;
3378 method
= SYMBOL_NATURAL_NAME (msymbol
);
3380 /* Is it a method? */
3381 if ((method
[0] != '-') && (method
[0] != '+'))
3384 if (sym_text
[0] == '[')
3385 /* Complete on shortened method method. */
3386 completion_list_add_name (method
+ 1, sym_text
, sym_text_len
, text
, word
);
3388 while ((strlen (method
) + 1) >= tmplen
)
3394 tmp
= xrealloc (tmp
, tmplen
);
3396 selector
= strchr (method
, ' ');
3397 if (selector
!= NULL
)
3400 category
= strchr (method
, '(');
3402 if ((category
!= NULL
) && (selector
!= NULL
))
3404 memcpy (tmp
, method
, (category
- method
));
3405 tmp
[category
- method
] = ' ';
3406 memcpy (tmp
+ (category
- method
) + 1, selector
, strlen (selector
) + 1);
3407 completion_list_add_name (tmp
, sym_text
, sym_text_len
, text
, word
);
3408 if (sym_text
[0] == '[')
3409 completion_list_add_name (tmp
+ 1, sym_text
, sym_text_len
, text
, word
);
3412 if (selector
!= NULL
)
3414 /* Complete on selector only. */
3415 strcpy (tmp
, selector
);
3416 tmp2
= strchr (tmp
, ']');
3420 completion_list_add_name (tmp
, sym_text
, sym_text_len
, text
, word
);
3424 /* Break the non-quoted text based on the characters which are in
3425 symbols. FIXME: This should probably be language-specific. */
3428 language_search_unquoted_string (char *text
, char *p
)
3430 for (; p
> text
; --p
)
3432 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
3436 if ((current_language
->la_language
== language_objc
))
3438 if (p
[-1] == ':') /* might be part of a method name */
3440 else if (p
[-1] == '[' && (p
[-2] == '-' || p
[-2] == '+'))
3441 p
-= 2; /* beginning of a method name */
3442 else if (p
[-1] == ' ' || p
[-1] == '(' || p
[-1] == ')')
3443 { /* might be part of a method name */
3446 /* Seeing a ' ' or a '(' is not conclusive evidence
3447 that we are in the middle of a method name. However,
3448 finding "-[" or "+[" should be pretty un-ambiguous.
3449 Unfortunately we have to find it now to decide. */
3452 if (isalnum (t
[-1]) || t
[-1] == '_' ||
3453 t
[-1] == ' ' || t
[-1] == ':' ||
3454 t
[-1] == '(' || t
[-1] == ')')
3459 if (t
[-1] == '[' && (t
[-2] == '-' || t
[-2] == '+'))
3460 p
= t
- 2; /* method name detected */
3461 /* else we leave with p unchanged */
3471 /* Return a NULL terminated array of all symbols (regardless of class)
3472 which begin by matching TEXT. If the answer is no symbols, then
3473 the return value is an array which contains only a NULL pointer.
3475 Problem: All of the symbols have to be copied because readline frees them.
3476 I'm not going to worry about this; hopefully there won't be that many. */
3479 make_symbol_completion_list (char *text
, char *word
)
3483 struct partial_symtab
*ps
;
3484 struct minimal_symbol
*msymbol
;
3485 struct objfile
*objfile
;
3486 struct block
*b
, *surrounding_static_block
= 0;
3487 struct dict_iterator iter
;
3489 struct partial_symbol
**psym
;
3490 /* The symbol we are completing on. Points in same buffer as text. */
3492 /* Length of sym_text. */
3495 /* Now look for the symbol we are supposed to complete on.
3496 FIXME: This should be language-specific. */
3500 char *quote_pos
= NULL
;
3502 /* First see if this is a quoted string. */
3504 for (p
= text
; *p
!= '\0'; ++p
)
3506 if (quote_found
!= '\0')
3508 if (*p
== quote_found
)
3509 /* Found close quote. */
3511 else if (*p
== '\\' && p
[1] == quote_found
)
3512 /* A backslash followed by the quote character
3513 doesn't end the string. */
3516 else if (*p
== '\'' || *p
== '"')
3522 if (quote_found
== '\'')
3523 /* A string within single quotes can be a symbol, so complete on it. */
3524 sym_text
= quote_pos
+ 1;
3525 else if (quote_found
== '"')
3526 /* A double-quoted string is never a symbol, nor does it make sense
3527 to complete it any other way. */
3529 return_val
= (char **) xmalloc (sizeof (char *));
3530 return_val
[0] = NULL
;
3535 /* It is not a quoted string. Break it based on the characters
3536 which are in symbols. */
3539 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
3548 sym_text_len
= strlen (sym_text
);
3550 return_val_size
= 100;
3551 return_val_index
= 0;
3552 return_val
= (char **) xmalloc ((return_val_size
+ 1) * sizeof (char *));
3553 return_val
[0] = NULL
;
3555 /* Look through the partial symtabs for all symbols which begin
3556 by matching SYM_TEXT. Add each one that you find to the list. */
3558 ALL_PSYMTABS (objfile
, ps
)
3560 /* If the psymtab's been read in we'll get it when we search
3561 through the blockvector. */
3565 for (psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
3566 psym
< (objfile
->global_psymbols
.list
+ ps
->globals_offset
3567 + ps
->n_global_syms
);
3570 /* If interrupted, then quit. */
3572 COMPLETION_LIST_ADD_SYMBOL (*psym
, sym_text
, sym_text_len
, text
, word
);
3575 for (psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
3576 psym
< (objfile
->static_psymbols
.list
+ ps
->statics_offset
3577 + ps
->n_static_syms
);
3581 COMPLETION_LIST_ADD_SYMBOL (*psym
, sym_text
, sym_text_len
, text
, word
);
3585 /* At this point scan through the misc symbol vectors and add each
3586 symbol you find to the list. Eventually we want to ignore
3587 anything that isn't a text symbol (everything else will be
3588 handled by the psymtab code above). */
3590 ALL_MSYMBOLS (objfile
, msymbol
)
3593 COMPLETION_LIST_ADD_SYMBOL (msymbol
, sym_text
, sym_text_len
, text
, word
);
3595 completion_list_objc_symbol (msymbol
, sym_text
, sym_text_len
, text
, word
);
3598 /* Search upwards from currently selected frame (so that we can
3599 complete on local vars. */
3601 for (b
= get_selected_block (0); b
!= NULL
; b
= BLOCK_SUPERBLOCK (b
))
3603 if (!BLOCK_SUPERBLOCK (b
))
3605 surrounding_static_block
= b
; /* For elmin of dups */
3608 /* Also catch fields of types defined in this places which match our
3609 text string. Only complete on types visible from current context. */
3611 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
3614 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3615 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
3617 struct type
*t
= SYMBOL_TYPE (sym
);
3618 enum type_code c
= TYPE_CODE (t
);
3620 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
3622 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
3624 if (TYPE_FIELD_NAME (t
, j
))
3626 completion_list_add_name (TYPE_FIELD_NAME (t
, j
),
3627 sym_text
, sym_text_len
, text
, word
);
3635 /* Go through the symtabs and check the externs and statics for
3636 symbols which match. */
3638 ALL_SYMTABS (objfile
, s
)
3641 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
3642 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
3644 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3648 ALL_SYMTABS (objfile
, s
)
3651 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
3652 /* Don't do this block twice. */
3653 if (b
== surrounding_static_block
)
3655 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
3657 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3661 return (return_val
);
3664 /* Like make_symbol_completion_list, but returns a list of symbols
3665 defined in a source file FILE. */
3668 make_file_symbol_completion_list (char *text
, char *word
, char *srcfile
)
3673 struct dict_iterator iter
;
3674 /* The symbol we are completing on. Points in same buffer as text. */
3676 /* Length of sym_text. */
3679 /* Now look for the symbol we are supposed to complete on.
3680 FIXME: This should be language-specific. */
3684 char *quote_pos
= NULL
;
3686 /* First see if this is a quoted string. */
3688 for (p
= text
; *p
!= '\0'; ++p
)
3690 if (quote_found
!= '\0')
3692 if (*p
== quote_found
)
3693 /* Found close quote. */
3695 else if (*p
== '\\' && p
[1] == quote_found
)
3696 /* A backslash followed by the quote character
3697 doesn't end the string. */
3700 else if (*p
== '\'' || *p
== '"')
3706 if (quote_found
== '\'')
3707 /* A string within single quotes can be a symbol, so complete on it. */
3708 sym_text
= quote_pos
+ 1;
3709 else if (quote_found
== '"')
3710 /* A double-quoted string is never a symbol, nor does it make sense
3711 to complete it any other way. */
3713 return_val
= (char **) xmalloc (sizeof (char *));
3714 return_val
[0] = NULL
;
3719 /* Not a quoted string. */
3720 sym_text
= language_search_unquoted_string (text
, p
);
3724 sym_text_len
= strlen (sym_text
);
3726 return_val_size
= 10;
3727 return_val_index
= 0;
3728 return_val
= (char **) xmalloc ((return_val_size
+ 1) * sizeof (char *));
3729 return_val
[0] = NULL
;
3731 /* Find the symtab for SRCFILE (this loads it if it was not yet read
3733 s
= lookup_symtab (srcfile
);
3736 /* Maybe they typed the file with leading directories, while the
3737 symbol tables record only its basename. */
3738 const char *tail
= lbasename (srcfile
);
3741 s
= lookup_symtab (tail
);
3744 /* If we have no symtab for that file, return an empty list. */
3746 return (return_val
);
3748 /* Go through this symtab and check the externs and statics for
3749 symbols which match. */
3751 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
3752 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
3754 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3757 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
3758 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
3760 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3763 return (return_val
);
3766 /* A helper function for make_source_files_completion_list. It adds
3767 another file name to a list of possible completions, growing the
3768 list as necessary. */
3771 add_filename_to_list (const char *fname
, char *text
, char *word
,
3772 char ***list
, int *list_used
, int *list_alloced
)
3775 size_t fnlen
= strlen (fname
);
3777 if (*list_used
+ 1 >= *list_alloced
)
3780 *list
= (char **) xrealloc ((char *) *list
,
3781 *list_alloced
* sizeof (char *));
3786 /* Return exactly fname. */
3787 new = xmalloc (fnlen
+ 5);
3788 strcpy (new, fname
);
3790 else if (word
> text
)
3792 /* Return some portion of fname. */
3793 new = xmalloc (fnlen
+ 5);
3794 strcpy (new, fname
+ (word
- text
));
3798 /* Return some of TEXT plus fname. */
3799 new = xmalloc (fnlen
+ (text
- word
) + 5);
3800 strncpy (new, word
, text
- word
);
3801 new[text
- word
] = '\0';
3802 strcat (new, fname
);
3804 (*list
)[*list_used
] = new;
3805 (*list
)[++*list_used
] = NULL
;
3809 not_interesting_fname (const char *fname
)
3811 static const char *illegal_aliens
[] = {
3812 "_globals_", /* inserted by coff_symtab_read */
3817 for (i
= 0; illegal_aliens
[i
]; i
++)
3819 if (strcmp (fname
, illegal_aliens
[i
]) == 0)
3825 /* Return a NULL terminated array of all source files whose names
3826 begin with matching TEXT. The file names are looked up in the
3827 symbol tables of this program. If the answer is no matchess, then
3828 the return value is an array which contains only a NULL pointer. */
3831 make_source_files_completion_list (char *text
, char *word
)
3834 struct partial_symtab
*ps
;
3835 struct objfile
*objfile
;
3837 int list_alloced
= 1;
3839 size_t text_len
= strlen (text
);
3840 char **list
= (char **) xmalloc (list_alloced
* sizeof (char *));
3841 const char *base_name
;
3845 if (!have_full_symbols () && !have_partial_symbols ())
3848 ALL_SYMTABS (objfile
, s
)
3850 if (not_interesting_fname (s
->filename
))
3852 if (!filename_seen (s
->filename
, 1, &first
)
3853 #if HAVE_DOS_BASED_FILE_SYSTEM
3854 && strncasecmp (s
->filename
, text
, text_len
) == 0
3856 && strncmp (s
->filename
, text
, text_len
) == 0
3860 /* This file matches for a completion; add it to the current
3862 add_filename_to_list (s
->filename
, text
, word
,
3863 &list
, &list_used
, &list_alloced
);
3867 /* NOTE: We allow the user to type a base name when the
3868 debug info records leading directories, but not the other
3869 way around. This is what subroutines of breakpoint
3870 command do when they parse file names. */
3871 base_name
= lbasename (s
->filename
);
3872 if (base_name
!= s
->filename
3873 && !filename_seen (base_name
, 1, &first
)
3874 #if HAVE_DOS_BASED_FILE_SYSTEM
3875 && strncasecmp (base_name
, text
, text_len
) == 0
3877 && strncmp (base_name
, text
, text_len
) == 0
3880 add_filename_to_list (base_name
, text
, word
,
3881 &list
, &list_used
, &list_alloced
);
3885 ALL_PSYMTABS (objfile
, ps
)
3887 if (not_interesting_fname (ps
->filename
))
3891 if (!filename_seen (ps
->filename
, 1, &first
)
3892 #if HAVE_DOS_BASED_FILE_SYSTEM
3893 && strncasecmp (ps
->filename
, text
, text_len
) == 0
3895 && strncmp (ps
->filename
, text
, text_len
) == 0
3899 /* This file matches for a completion; add it to the
3900 current list of matches. */
3901 add_filename_to_list (ps
->filename
, text
, word
,
3902 &list
, &list_used
, &list_alloced
);
3907 base_name
= lbasename (ps
->filename
);
3908 if (base_name
!= ps
->filename
3909 && !filename_seen (base_name
, 1, &first
)
3910 #if HAVE_DOS_BASED_FILE_SYSTEM
3911 && strncasecmp (base_name
, text
, text_len
) == 0
3913 && strncmp (base_name
, text
, text_len
) == 0
3916 add_filename_to_list (base_name
, text
, word
,
3917 &list
, &list_used
, &list_alloced
);
3925 /* Determine if PC is in the prologue of a function. The prologue is the area
3926 between the first instruction of a function, and the first executable line.
3927 Returns 1 if PC *might* be in prologue, 0 if definately *not* in prologue.
3929 If non-zero, func_start is where we think the prologue starts, possibly
3930 by previous examination of symbol table information.
3934 in_prologue (CORE_ADDR pc
, CORE_ADDR func_start
)
3936 struct symtab_and_line sal
;
3937 CORE_ADDR func_addr
, func_end
;
3939 /* We have several sources of information we can consult to figure
3941 - Compilers usually emit line number info that marks the prologue
3942 as its own "source line". So the ending address of that "line"
3943 is the end of the prologue. If available, this is the most
3945 - The minimal symbols and partial symbols, which can usually tell
3946 us the starting and ending addresses of a function.
3947 - If we know the function's start address, we can call the
3948 architecture-defined SKIP_PROLOGUE function to analyze the
3949 instruction stream and guess where the prologue ends.
3950 - Our `func_start' argument; if non-zero, this is the caller's
3951 best guess as to the function's entry point. At the time of
3952 this writing, handle_inferior_event doesn't get this right, so
3953 it should be our last resort. */
3955 /* Consult the partial symbol table, to find which function
3957 if (! find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
3959 CORE_ADDR prologue_end
;
3961 /* We don't even have minsym information, so fall back to using
3962 func_start, if given. */
3964 return 1; /* We *might* be in a prologue. */
3966 prologue_end
= SKIP_PROLOGUE (func_start
);
3968 return func_start
<= pc
&& pc
< prologue_end
;
3971 /* If we have line number information for the function, that's
3972 usually pretty reliable. */
3973 sal
= find_pc_line (func_addr
, 0);
3975 /* Now sal describes the source line at the function's entry point,
3976 which (by convention) is the prologue. The end of that "line",
3977 sal.end, is the end of the prologue.
3979 Note that, for functions whose source code is all on a single
3980 line, the line number information doesn't always end up this way.
3981 So we must verify that our purported end-of-prologue address is
3982 *within* the function, not at its start or end. */
3984 || sal
.end
<= func_addr
3985 || func_end
<= sal
.end
)
3987 /* We don't have any good line number info, so use the minsym
3988 information, together with the architecture-specific prologue
3990 CORE_ADDR prologue_end
= SKIP_PROLOGUE (func_addr
);
3992 return func_addr
<= pc
&& pc
< prologue_end
;
3995 /* We have line number info, and it looks good. */
3996 return func_addr
<= pc
&& pc
< sal
.end
;
3999 /* Given PC at the function's start address, attempt to find the
4000 prologue end using SAL information. Return zero if the skip fails.
4002 A non-optimized prologue traditionally has one SAL for the function
4003 and a second for the function body. A single line function has
4004 them both pointing at the same line.
4006 An optimized prologue is similar but the prologue may contain
4007 instructions (SALs) from the instruction body. Need to skip those
4008 while not getting into the function body.
4010 The functions end point and an increasing SAL line are used as
4011 indicators of the prologue's endpoint.
4013 This code is based on the function refine_prologue_limit (versions
4014 found in both ia64 and ppc). */
4017 skip_prologue_using_sal (CORE_ADDR func_addr
)
4019 struct symtab_and_line prologue_sal
;
4023 /* Get an initial range for the function. */
4024 find_pc_partial_function (func_addr
, NULL
, &start_pc
, &end_pc
);
4025 start_pc
+= DEPRECATED_FUNCTION_START_OFFSET
;
4027 prologue_sal
= find_pc_line (start_pc
, 0);
4028 if (prologue_sal
.line
!= 0)
4030 while (prologue_sal
.end
< end_pc
)
4032 struct symtab_and_line sal
;
4034 sal
= find_pc_line (prologue_sal
.end
, 0);
4037 /* Assume that a consecutive SAL for the same (or larger)
4038 line mark the prologue -> body transition. */
4039 if (sal
.line
>= prologue_sal
.line
)
4041 /* The case in which compiler's optimizer/scheduler has
4042 moved instructions into the prologue. We look ahead in
4043 the function looking for address ranges whose
4044 corresponding line number is less the first one that we
4045 found for the function. This is more conservative then
4046 refine_prologue_limit which scans a large number of SALs
4047 looking for any in the prologue */
4051 return prologue_sal
.end
;
4054 struct symtabs_and_lines
4055 decode_line_spec (char *string
, int funfirstline
)
4057 struct symtabs_and_lines sals
;
4058 struct symtab_and_line cursal
;
4061 error ("Empty line specification.");
4063 /* We use whatever is set as the current source line. We do not try
4064 and get a default or it will recursively call us! */
4065 cursal
= get_current_source_symtab_and_line ();
4067 sals
= decode_line_1 (&string
, funfirstline
,
4068 cursal
.symtab
, cursal
.line
,
4069 (char ***) NULL
, NULL
);
4072 error ("Junk at end of line specification: %s", string
);
4077 static char *name_of_main
;
4080 set_main_name (const char *name
)
4082 if (name_of_main
!= NULL
)
4084 xfree (name_of_main
);
4085 name_of_main
= NULL
;
4089 name_of_main
= xstrdup (name
);
4096 if (name_of_main
!= NULL
)
4097 return name_of_main
;
4104 _initialize_symtab (void)
4106 add_info ("variables", variables_info
,
4107 "All global and static variable names, or those matching REGEXP.");
4109 add_com ("whereis", class_info
, variables_info
,
4110 "All global and static variable names, or those matching REGEXP.");
4112 add_info ("functions", functions_info
,
4113 "All function names, or those matching REGEXP.");
4116 /* FIXME: This command has at least the following problems:
4117 1. It prints builtin types (in a very strange and confusing fashion).
4118 2. It doesn't print right, e.g. with
4119 typedef struct foo *FOO
4120 type_print prints "FOO" when we want to make it (in this situation)
4121 print "struct foo *".
4122 I also think "ptype" or "whatis" is more likely to be useful (but if
4123 there is much disagreement "info types" can be fixed). */
4124 add_info ("types", types_info
,
4125 "All type names, or those matching REGEXP.");
4127 add_info ("sources", sources_info
,
4128 "Source files in the program.");
4130 add_com ("rbreak", class_breakpoint
, rbreak_command
,
4131 "Set a breakpoint for all functions matching REGEXP.");
4135 add_com ("lf", class_info
, sources_info
, "Source files in the program");
4136 add_com ("lg", class_info
, variables_info
,
4137 "All global and static variable names, or those matching REGEXP.");
4140 /* Initialize the one built-in type that isn't language dependent... */
4141 builtin_type_error
= init_type (TYPE_CODE_ERROR
, 0, 0,
4142 "<unknown type>", (struct objfile
*) NULL
);