1 /* Symbol table lookup for the GNU debugger, GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009,
5 2010 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
32 #include "call-cmds.h"
33 #include "gdb_regex.h"
34 #include "expression.h"
40 #include "filenames.h" /* for FILENAME_CMP */
41 #include "objc-lang.h"
48 #include "gdb_obstack.h"
50 #include "dictionary.h"
52 #include <sys/types.h>
54 #include "gdb_string.h"
58 #include "cp-support.h"
60 #include "gdb_assert.h"
63 #include "macroscope.h"
65 /* Prototypes for local functions */
67 static void completion_list_add_name (char *, char *, int, char *, char *);
69 static void rbreak_command (char *, int);
71 static void types_info (char *, int);
73 static void functions_info (char *, int);
75 static void variables_info (char *, int);
77 static void sources_info (char *, int);
79 static void output_source_filename (const char *, int *);
81 static int find_line_common (struct linetable
*, int, int *);
83 /* This one is used by linespec.c */
85 char *operator_chars (char *p
, char **end
);
87 static struct symbol
*lookup_symbol_aux (const char *name
,
88 const struct block
*block
,
89 const domain_enum domain
,
90 enum language language
,
91 int *is_a_field_of_this
);
94 struct symbol
*lookup_symbol_aux_local (const char *name
,
95 const struct block
*block
,
96 const domain_enum domain
);
99 struct symbol
*lookup_symbol_aux_symtabs (int block_index
,
101 const domain_enum domain
);
104 struct symbol
*lookup_symbol_aux_psymtabs (int block_index
,
106 const domain_enum domain
);
108 static int file_matches (char *, char **, int);
110 static void print_symbol_info (domain_enum
,
111 struct symtab
*, struct symbol
*, int, char *);
113 static void print_msymbol_info (struct minimal_symbol
*);
115 static void symtab_symbol_info (char *, domain_enum
, int);
117 void _initialize_symtab (void);
121 /* Allow the user to configure the debugger behavior with respect
122 to multiple-choice menus when more than one symbol matches during
125 const char multiple_symbols_ask
[] = "ask";
126 const char multiple_symbols_all
[] = "all";
127 const char multiple_symbols_cancel
[] = "cancel";
128 static const char *multiple_symbols_modes
[] =
130 multiple_symbols_ask
,
131 multiple_symbols_all
,
132 multiple_symbols_cancel
,
135 static const char *multiple_symbols_mode
= multiple_symbols_all
;
137 /* Read-only accessor to AUTO_SELECT_MODE. */
140 multiple_symbols_select_mode (void)
142 return multiple_symbols_mode
;
145 /* Block in which the most recently searched-for symbol was found.
146 Might be better to make this a parameter to lookup_symbol and
149 const struct block
*block_found
;
151 /* Check for a symtab of a specific name; first in symtabs, then in
152 psymtabs. *If* there is no '/' in the name, a match after a '/'
153 in the symtab filename will also work. */
156 lookup_symtab (const char *name
)
159 struct partial_symtab
*ps
;
160 struct objfile
*objfile
;
161 char *real_path
= NULL
;
162 char *full_path
= NULL
;
164 /* Here we are interested in canonicalizing an absolute path, not
165 absolutizing a relative path. */
166 if (IS_ABSOLUTE_PATH (name
))
168 full_path
= xfullpath (name
);
169 make_cleanup (xfree
, full_path
);
170 real_path
= gdb_realpath (name
);
171 make_cleanup (xfree
, real_path
);
176 /* First, search for an exact match */
178 ALL_SYMTABS (objfile
, s
)
180 if (FILENAME_CMP (name
, s
->filename
) == 0)
185 /* If the user gave us an absolute path, try to find the file in
186 this symtab and use its absolute path. */
188 if (full_path
!= NULL
)
190 const char *fp
= symtab_to_fullname (s
);
191 if (fp
!= NULL
&& FILENAME_CMP (full_path
, fp
) == 0)
197 if (real_path
!= NULL
)
199 char *fullname
= symtab_to_fullname (s
);
200 if (fullname
!= NULL
)
202 char *rp
= gdb_realpath (fullname
);
203 make_cleanup (xfree
, rp
);
204 if (FILENAME_CMP (real_path
, rp
) == 0)
212 /* Now, search for a matching tail (only if name doesn't have any dirs) */
214 if (lbasename (name
) == name
)
215 ALL_SYMTABS (objfile
, s
)
217 if (FILENAME_CMP (lbasename (s
->filename
), name
) == 0)
221 /* Same search rules as above apply here, but now we look thru the
224 ps
= lookup_partial_symtab (name
);
229 error (_("Internal: readin %s pst for `%s' found when no symtab found."),
232 s
= PSYMTAB_TO_SYMTAB (ps
);
237 /* At this point, we have located the psymtab for this file, but
238 the conversion to a symtab has failed. This usually happens
239 when we are looking up an include file. In this case,
240 PSYMTAB_TO_SYMTAB doesn't return a symtab, even though one has
241 been created. So, we need to run through the symtabs again in
242 order to find the file.
243 XXX - This is a crock, and should be fixed inside of the the
244 symbol parsing routines. */
248 /* Lookup the partial symbol table of a source file named NAME.
249 *If* there is no '/' in the name, a match after a '/'
250 in the psymtab filename will also work. */
252 struct partial_symtab
*
253 lookup_partial_symtab (const char *name
)
255 struct partial_symtab
*pst
;
256 struct objfile
*objfile
;
257 char *full_path
= NULL
;
258 char *real_path
= NULL
;
260 /* Here we are interested in canonicalizing an absolute path, not
261 absolutizing a relative path. */
262 if (IS_ABSOLUTE_PATH (name
))
264 full_path
= xfullpath (name
);
265 make_cleanup (xfree
, full_path
);
266 real_path
= gdb_realpath (name
);
267 make_cleanup (xfree
, real_path
);
270 ALL_PSYMTABS (objfile
, pst
)
272 if (FILENAME_CMP (name
, pst
->filename
) == 0)
277 /* If the user gave us an absolute path, try to find the file in
278 this symtab and use its absolute path. */
279 if (full_path
!= NULL
)
281 psymtab_to_fullname (pst
);
282 if (pst
->fullname
!= NULL
283 && FILENAME_CMP (full_path
, pst
->fullname
) == 0)
289 if (real_path
!= NULL
)
292 psymtab_to_fullname (pst
);
293 if (pst
->fullname
!= NULL
)
295 rp
= gdb_realpath (pst
->fullname
);
296 make_cleanup (xfree
, rp
);
298 if (rp
!= NULL
&& FILENAME_CMP (real_path
, rp
) == 0)
305 /* Now, search for a matching tail (only if name doesn't have any dirs) */
307 if (lbasename (name
) == name
)
308 ALL_PSYMTABS (objfile
, pst
)
310 if (FILENAME_CMP (lbasename (pst
->filename
), name
) == 0)
317 /* Mangle a GDB method stub type. This actually reassembles the pieces of the
318 full method name, which consist of the class name (from T), the unadorned
319 method name from METHOD_ID, and the signature for the specific overload,
320 specified by SIGNATURE_ID. Note that this function is g++ specific. */
323 gdb_mangle_name (struct type
*type
, int method_id
, int signature_id
)
325 int mangled_name_len
;
327 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
328 struct fn_field
*method
= &f
[signature_id
];
329 char *field_name
= TYPE_FN_FIELDLIST_NAME (type
, method_id
);
330 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, signature_id
);
331 char *newname
= type_name_no_tag (type
);
333 /* Does the form of physname indicate that it is the full mangled name
334 of a constructor (not just the args)? */
335 int is_full_physname_constructor
;
338 int is_destructor
= is_destructor_name (physname
);
339 /* Need a new type prefix. */
340 char *const_prefix
= method
->is_const
? "C" : "";
341 char *volatile_prefix
= method
->is_volatile
? "V" : "";
343 int len
= (newname
== NULL
? 0 : strlen (newname
));
345 /* Nothing to do if physname already contains a fully mangled v3 abi name
346 or an operator name. */
347 if ((physname
[0] == '_' && physname
[1] == 'Z')
348 || is_operator_name (field_name
))
349 return xstrdup (physname
);
351 is_full_physname_constructor
= is_constructor_name (physname
);
354 is_full_physname_constructor
|| (newname
&& strcmp (field_name
, newname
) == 0);
357 is_destructor
= (strncmp (physname
, "__dt", 4) == 0);
359 if (is_destructor
|| is_full_physname_constructor
)
361 mangled_name
= (char *) xmalloc (strlen (physname
) + 1);
362 strcpy (mangled_name
, physname
);
368 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
370 else if (physname
[0] == 't' || physname
[0] == 'Q')
372 /* The physname for template and qualified methods already includes
374 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
380 sprintf (buf
, "__%s%s%d", const_prefix
, volatile_prefix
, len
);
382 mangled_name_len
= ((is_constructor
? 0 : strlen (field_name
))
383 + strlen (buf
) + len
+ strlen (physname
) + 1);
386 mangled_name
= (char *) xmalloc (mangled_name_len
);
388 mangled_name
[0] = '\0';
390 strcpy (mangled_name
, field_name
);
392 strcat (mangled_name
, buf
);
393 /* If the class doesn't have a name, i.e. newname NULL, then we just
394 mangle it using 0 for the length of the class. Thus it gets mangled
395 as something starting with `::' rather than `classname::'. */
397 strcat (mangled_name
, newname
);
399 strcat (mangled_name
, physname
);
400 return (mangled_name
);
404 /* Initialize the language dependent portion of a symbol
405 depending upon the language for the symbol. */
407 symbol_init_language_specific (struct general_symbol_info
*gsymbol
,
408 enum language language
)
410 gsymbol
->language
= language
;
411 if (gsymbol
->language
== language_cplus
412 || gsymbol
->language
== language_java
413 || gsymbol
->language
== language_objc
)
415 gsymbol
->language_specific
.cplus_specific
.demangled_name
= NULL
;
419 memset (&gsymbol
->language_specific
, 0,
420 sizeof (gsymbol
->language_specific
));
424 /* Functions to initialize a symbol's mangled name. */
426 /* Objects of this type are stored in the demangled name hash table. */
427 struct demangled_name_entry
433 /* Hash function for the demangled name hash. */
435 hash_demangled_name_entry (const void *data
)
437 const struct demangled_name_entry
*e
= data
;
438 return htab_hash_string (e
->mangled
);
441 /* Equality function for the demangled name hash. */
443 eq_demangled_name_entry (const void *a
, const void *b
)
445 const struct demangled_name_entry
*da
= a
;
446 const struct demangled_name_entry
*db
= b
;
447 return strcmp (da
->mangled
, db
->mangled
) == 0;
450 /* Create the hash table used for demangled names. Each hash entry is
451 a pair of strings; one for the mangled name and one for the demangled
452 name. The entry is hashed via just the mangled name. */
455 create_demangled_names_hash (struct objfile
*objfile
)
457 /* Choose 256 as the starting size of the hash table, somewhat arbitrarily.
458 The hash table code will round this up to the next prime number.
459 Choosing a much larger table size wastes memory, and saves only about
460 1% in symbol reading. */
462 objfile
->demangled_names_hash
= htab_create_alloc
463 (256, hash_demangled_name_entry
, eq_demangled_name_entry
,
464 NULL
, xcalloc
, xfree
);
467 /* Try to determine the demangled name for a symbol, based on the
468 language of that symbol. If the language is set to language_auto,
469 it will attempt to find any demangling algorithm that works and
470 then set the language appropriately. The returned name is allocated
471 by the demangler and should be xfree'd. */
474 symbol_find_demangled_name (struct general_symbol_info
*gsymbol
,
477 char *demangled
= NULL
;
479 if (gsymbol
->language
== language_unknown
)
480 gsymbol
->language
= language_auto
;
482 if (gsymbol
->language
== language_objc
483 || gsymbol
->language
== language_auto
)
486 objc_demangle (mangled
, 0);
487 if (demangled
!= NULL
)
489 gsymbol
->language
= language_objc
;
493 if (gsymbol
->language
== language_cplus
494 || gsymbol
->language
== language_auto
)
497 cplus_demangle (mangled
, DMGL_PARAMS
| DMGL_ANSI
| DMGL_VERBOSE
);
498 if (demangled
!= NULL
)
500 gsymbol
->language
= language_cplus
;
504 if (gsymbol
->language
== language_java
)
507 cplus_demangle (mangled
,
508 DMGL_PARAMS
| DMGL_ANSI
| DMGL_JAVA
);
509 if (demangled
!= NULL
)
511 gsymbol
->language
= language_java
;
518 /* Set both the mangled and demangled (if any) names for GSYMBOL based
519 on LINKAGE_NAME and LEN. Ordinarily, NAME is copied onto the
520 objfile's obstack; but if COPY_NAME is 0 and if NAME is
521 NUL-terminated, then this function assumes that NAME is already
522 correctly saved (either permanently or with a lifetime tied to the
523 objfile), and it will not be copied.
525 The hash table corresponding to OBJFILE is used, and the memory
526 comes from that objfile's objfile_obstack. LINKAGE_NAME is copied,
527 so the pointer can be discarded after calling this function. */
529 /* We have to be careful when dealing with Java names: when we run
530 into a Java minimal symbol, we don't know it's a Java symbol, so it
531 gets demangled as a C++ name. This is unfortunate, but there's not
532 much we can do about it: but when demangling partial symbols and
533 regular symbols, we'd better not reuse the wrong demangled name.
534 (See PR gdb/1039.) We solve this by putting a distinctive prefix
535 on Java names when storing them in the hash table. */
537 /* FIXME: carlton/2003-03-13: This is an unfortunate situation. I
538 don't mind the Java prefix so much: different languages have
539 different demangling requirements, so it's only natural that we
540 need to keep language data around in our demangling cache. But
541 it's not good that the minimal symbol has the wrong demangled name.
542 Unfortunately, I can't think of any easy solution to that
545 #define JAVA_PREFIX "##JAVA$$"
546 #define JAVA_PREFIX_LEN 8
549 symbol_set_names (struct general_symbol_info
*gsymbol
,
550 const char *linkage_name
, int len
, int copy_name
,
551 struct objfile
*objfile
)
553 struct demangled_name_entry
**slot
;
554 /* A 0-terminated copy of the linkage name. */
555 const char *linkage_name_copy
;
556 /* A copy of the linkage name that might have a special Java prefix
557 added to it, for use when looking names up in the hash table. */
558 const char *lookup_name
;
559 /* The length of lookup_name. */
561 struct demangled_name_entry entry
;
563 if (gsymbol
->language
== language_ada
)
565 /* In Ada, we do the symbol lookups using the mangled name, so
566 we can save some space by not storing the demangled name.
568 As a side note, we have also observed some overlap between
569 the C++ mangling and Ada mangling, similarly to what has
570 been observed with Java. Because we don't store the demangled
571 name with the symbol, we don't need to use the same trick
574 gsymbol
->name
= (char *) linkage_name
;
577 gsymbol
->name
= obstack_alloc (&objfile
->objfile_obstack
, len
+ 1);
578 memcpy (gsymbol
->name
, linkage_name
, len
);
579 gsymbol
->name
[len
] = '\0';
581 gsymbol
->language_specific
.cplus_specific
.demangled_name
= NULL
;
586 if (objfile
->demangled_names_hash
== NULL
)
587 create_demangled_names_hash (objfile
);
589 /* The stabs reader generally provides names that are not
590 NUL-terminated; most of the other readers don't do this, so we
591 can just use the given copy, unless we're in the Java case. */
592 if (gsymbol
->language
== language_java
)
595 lookup_len
= len
+ JAVA_PREFIX_LEN
;
597 alloc_name
= alloca (lookup_len
+ 1);
598 memcpy (alloc_name
, JAVA_PREFIX
, JAVA_PREFIX_LEN
);
599 memcpy (alloc_name
+ JAVA_PREFIX_LEN
, linkage_name
, len
);
600 alloc_name
[lookup_len
] = '\0';
602 lookup_name
= alloc_name
;
603 linkage_name_copy
= alloc_name
+ JAVA_PREFIX_LEN
;
605 else if (linkage_name
[len
] != '\0')
610 alloc_name
= alloca (lookup_len
+ 1);
611 memcpy (alloc_name
, linkage_name
, len
);
612 alloc_name
[lookup_len
] = '\0';
614 lookup_name
= alloc_name
;
615 linkage_name_copy
= alloc_name
;
620 lookup_name
= linkage_name
;
621 linkage_name_copy
= linkage_name
;
624 entry
.mangled
= (char *) lookup_name
;
625 slot
= ((struct demangled_name_entry
**)
626 htab_find_slot (objfile
->demangled_names_hash
,
629 /* If this name is not in the hash table, add it. */
632 char *demangled_name
= symbol_find_demangled_name (gsymbol
,
634 int demangled_len
= demangled_name
? strlen (demangled_name
) : 0;
636 /* Suppose we have demangled_name==NULL, copy_name==0, and
637 lookup_name==linkage_name. In this case, we already have the
638 mangled name saved, and we don't have a demangled name. So,
639 you might think we could save a little space by not recording
640 this in the hash table at all.
642 It turns out that it is actually important to still save such
643 an entry in the hash table, because storing this name gives
644 us better backache hit rates for partial symbols. */
645 if (!copy_name
&& lookup_name
== linkage_name
)
647 *slot
= obstack_alloc (&objfile
->objfile_obstack
,
648 offsetof (struct demangled_name_entry
,
650 + demangled_len
+ 1);
651 (*slot
)->mangled
= (char *) lookup_name
;
655 /* If we must copy the mangled name, put it directly after
656 the demangled name so we can have a single
658 *slot
= obstack_alloc (&objfile
->objfile_obstack
,
659 offsetof (struct demangled_name_entry
,
661 + lookup_len
+ demangled_len
+ 2);
662 (*slot
)->mangled
= &((*slot
)->demangled
[demangled_len
+ 1]);
663 strcpy ((*slot
)->mangled
, lookup_name
);
666 if (demangled_name
!= NULL
)
668 strcpy ((*slot
)->demangled
, demangled_name
);
669 xfree (demangled_name
);
672 (*slot
)->demangled
[0] = '\0';
675 gsymbol
->name
= (*slot
)->mangled
+ lookup_len
- len
;
676 if ((*slot
)->demangled
[0] != '\0')
677 gsymbol
->language_specific
.cplus_specific
.demangled_name
678 = (*slot
)->demangled
;
680 gsymbol
->language_specific
.cplus_specific
.demangled_name
= NULL
;
683 /* Return the source code name of a symbol. In languages where
684 demangling is necessary, this is the demangled name. */
687 symbol_natural_name (const struct general_symbol_info
*gsymbol
)
689 switch (gsymbol
->language
)
694 if (gsymbol
->language_specific
.cplus_specific
.demangled_name
!= NULL
)
695 return gsymbol
->language_specific
.cplus_specific
.demangled_name
;
698 if (gsymbol
->language_specific
.cplus_specific
.demangled_name
!= NULL
)
699 return gsymbol
->language_specific
.cplus_specific
.demangled_name
;
701 return ada_decode_symbol (gsymbol
);
706 return gsymbol
->name
;
709 /* Return the demangled name for a symbol based on the language for
710 that symbol. If no demangled name exists, return NULL. */
712 symbol_demangled_name (const struct general_symbol_info
*gsymbol
)
714 switch (gsymbol
->language
)
719 if (gsymbol
->language_specific
.cplus_specific
.demangled_name
!= NULL
)
720 return gsymbol
->language_specific
.cplus_specific
.demangled_name
;
723 if (gsymbol
->language_specific
.cplus_specific
.demangled_name
!= NULL
)
724 return gsymbol
->language_specific
.cplus_specific
.demangled_name
;
726 return ada_decode_symbol (gsymbol
);
734 /* Return the search name of a symbol---generally the demangled or
735 linkage name of the symbol, depending on how it will be searched for.
736 If there is no distinct demangled name, then returns the same value
737 (same pointer) as SYMBOL_LINKAGE_NAME. */
739 symbol_search_name (const struct general_symbol_info
*gsymbol
)
741 if (gsymbol
->language
== language_ada
)
742 return gsymbol
->name
;
744 return symbol_natural_name (gsymbol
);
747 /* Initialize the structure fields to zero values. */
749 init_sal (struct symtab_and_line
*sal
)
757 sal
->explicit_pc
= 0;
758 sal
->explicit_line
= 0;
762 /* Return 1 if the two sections are the same, or if they could
763 plausibly be copies of each other, one in an original object
764 file and another in a separated debug file. */
767 matching_obj_sections (struct obj_section
*obj_first
,
768 struct obj_section
*obj_second
)
770 asection
*first
= obj_first
? obj_first
->the_bfd_section
: NULL
;
771 asection
*second
= obj_second
? obj_second
->the_bfd_section
: NULL
;
774 /* If they're the same section, then they match. */
778 /* If either is NULL, give up. */
779 if (first
== NULL
|| second
== NULL
)
782 /* This doesn't apply to absolute symbols. */
783 if (first
->owner
== NULL
|| second
->owner
== NULL
)
786 /* If they're in the same object file, they must be different sections. */
787 if (first
->owner
== second
->owner
)
790 /* Check whether the two sections are potentially corresponding. They must
791 have the same size, address, and name. We can't compare section indexes,
792 which would be more reliable, because some sections may have been
794 if (bfd_get_section_size (first
) != bfd_get_section_size (second
))
797 /* In-memory addresses may start at a different offset, relativize them. */
798 if (bfd_get_section_vma (first
->owner
, first
)
799 - bfd_get_start_address (first
->owner
)
800 != bfd_get_section_vma (second
->owner
, second
)
801 - bfd_get_start_address (second
->owner
))
804 if (bfd_get_section_name (first
->owner
, first
) == NULL
805 || bfd_get_section_name (second
->owner
, second
) == NULL
806 || strcmp (bfd_get_section_name (first
->owner
, first
),
807 bfd_get_section_name (second
->owner
, second
)) != 0)
810 /* Otherwise check that they are in corresponding objfiles. */
813 if (obj
->obfd
== first
->owner
)
815 gdb_assert (obj
!= NULL
);
817 if (obj
->separate_debug_objfile
!= NULL
818 && obj
->separate_debug_objfile
->obfd
== second
->owner
)
820 if (obj
->separate_debug_objfile_backlink
!= NULL
821 && obj
->separate_debug_objfile_backlink
->obfd
== second
->owner
)
827 /* Find which partial symtab contains PC and SECTION starting at psymtab PST.
828 We may find a different psymtab than PST. See FIND_PC_SECT_PSYMTAB. */
830 static struct partial_symtab
*
831 find_pc_sect_psymtab_closer (CORE_ADDR pc
, struct obj_section
*section
,
832 struct partial_symtab
*pst
,
833 struct minimal_symbol
*msymbol
)
835 struct objfile
*objfile
= pst
->objfile
;
836 struct partial_symtab
*tpst
;
837 struct partial_symtab
*best_pst
= pst
;
838 CORE_ADDR best_addr
= pst
->textlow
;
840 /* An objfile that has its functions reordered might have
841 many partial symbol tables containing the PC, but
842 we want the partial symbol table that contains the
843 function containing the PC. */
844 if (!(objfile
->flags
& OBJF_REORDERED
) &&
845 section
== 0) /* can't validate section this way */
851 /* The code range of partial symtabs sometimes overlap, so, in
852 the loop below, we need to check all partial symtabs and
853 find the one that fits better for the given PC address. We
854 select the partial symtab that contains a symbol whose
855 address is closest to the PC address. By closest we mean
856 that find_pc_sect_symbol returns the symbol with address
857 that is closest and still less than the given PC. */
858 for (tpst
= pst
; tpst
!= NULL
; tpst
= tpst
->next
)
860 if (pc
>= tpst
->textlow
&& pc
< tpst
->texthigh
)
862 struct partial_symbol
*p
;
865 /* NOTE: This assumes that every psymbol has a
866 corresponding msymbol, which is not necessarily
867 true; the debug info might be much richer than the
868 object's symbol table. */
869 p
= find_pc_sect_psymbol (tpst
, pc
, section
);
871 && SYMBOL_VALUE_ADDRESS (p
)
872 == SYMBOL_VALUE_ADDRESS (msymbol
))
875 /* Also accept the textlow value of a psymtab as a
876 "symbol", to provide some support for partial
877 symbol tables with line information but no debug
878 symbols (e.g. those produced by an assembler). */
880 this_addr
= SYMBOL_VALUE_ADDRESS (p
);
882 this_addr
= tpst
->textlow
;
884 /* Check whether it is closer than our current
885 BEST_ADDR. Since this symbol address is
886 necessarily lower or equal to PC, the symbol closer
887 to PC is the symbol which address is the highest.
888 This way we return the psymtab which contains such
889 best match symbol. This can help in cases where the
890 symbol information/debuginfo is not complete, like
891 for instance on IRIX6 with gcc, where no debug info
892 is emitted for statics. (See also the nodebug.exp
894 if (this_addr
> best_addr
)
896 best_addr
= this_addr
;
904 /* Find which partial symtab contains PC and SECTION. Return 0 if
905 none. We return the psymtab that contains a symbol whose address
906 exactly matches PC, or, if we cannot find an exact match, the
907 psymtab that contains a symbol whose address is closest to PC. */
908 struct partial_symtab
*
909 find_pc_sect_psymtab (CORE_ADDR pc
, struct obj_section
*section
)
911 struct objfile
*objfile
;
912 struct minimal_symbol
*msymbol
;
914 /* If we know that this is not a text address, return failure. This is
915 necessary because we loop based on texthigh and textlow, which do
916 not include the data ranges. */
917 msymbol
= lookup_minimal_symbol_by_pc_section (pc
, section
);
919 && (MSYMBOL_TYPE (msymbol
) == mst_data
920 || MSYMBOL_TYPE (msymbol
) == mst_bss
921 || MSYMBOL_TYPE (msymbol
) == mst_abs
922 || MSYMBOL_TYPE (msymbol
) == mst_file_data
923 || MSYMBOL_TYPE (msymbol
) == mst_file_bss
))
926 /* Try just the PSYMTABS_ADDRMAP mapping first as it has better granularity
927 than the later used TEXTLOW/TEXTHIGH one. */
929 ALL_OBJFILES (objfile
)
930 if (objfile
->psymtabs_addrmap
!= NULL
)
932 struct partial_symtab
*pst
;
934 pst
= addrmap_find (objfile
->psymtabs_addrmap
, pc
);
937 /* FIXME: addrmaps currently do not handle overlayed sections,
938 so fall back to the non-addrmap case if we're debugging
939 overlays and the addrmap returned the wrong section. */
940 if (overlay_debugging
&& msymbol
&& section
)
942 struct partial_symbol
*p
;
943 /* NOTE: This assumes that every psymbol has a
944 corresponding msymbol, which is not necessarily
945 true; the debug info might be much richer than the
946 object's symbol table. */
947 p
= find_pc_sect_psymbol (pst
, pc
, section
);
949 || SYMBOL_VALUE_ADDRESS (p
)
950 != SYMBOL_VALUE_ADDRESS (msymbol
))
954 /* We do not try to call FIND_PC_SECT_PSYMTAB_CLOSER as
955 PSYMTABS_ADDRMAP we used has already the best 1-byte
956 granularity and FIND_PC_SECT_PSYMTAB_CLOSER may mislead us into
957 a worse chosen section due to the TEXTLOW/TEXTHIGH ranges
964 /* Existing PSYMTABS_ADDRMAP mapping is present even for PARTIAL_SYMTABs
965 which still have no corresponding full SYMTABs read. But it is not
966 present for non-DWARF2 debug infos not supporting PSYMTABS_ADDRMAP in GDB
969 ALL_OBJFILES (objfile
)
971 struct partial_symtab
*pst
;
973 /* Check even OBJFILE with non-zero PSYMTABS_ADDRMAP as only several of
974 its CUs may be missing in PSYMTABS_ADDRMAP as they may be varying
975 debug info type in single OBJFILE. */
977 ALL_OBJFILE_PSYMTABS (objfile
, pst
)
978 if (pc
>= pst
->textlow
&& pc
< pst
->texthigh
)
980 struct partial_symtab
*best_pst
;
982 best_pst
= find_pc_sect_psymtab_closer (pc
, section
, pst
,
984 if (best_pst
!= NULL
)
992 /* Find which partial symtab contains PC. Return 0 if none.
993 Backward compatibility, no section */
995 struct partial_symtab
*
996 find_pc_psymtab (CORE_ADDR pc
)
998 return find_pc_sect_psymtab (pc
, find_pc_mapped_section (pc
));
1001 /* Find which partial symbol within a psymtab matches PC and SECTION.
1002 Return 0 if none. Check all psymtabs if PSYMTAB is 0. */
1004 struct partial_symbol
*
1005 find_pc_sect_psymbol (struct partial_symtab
*psymtab
, CORE_ADDR pc
,
1006 struct obj_section
*section
)
1008 struct partial_symbol
*best
= NULL
, *p
, **pp
;
1012 psymtab
= find_pc_sect_psymtab (pc
, section
);
1016 /* Cope with programs that start at address 0 */
1017 best_pc
= (psymtab
->textlow
!= 0) ? psymtab
->textlow
- 1 : 0;
1019 /* Search the global symbols as well as the static symbols, so that
1020 find_pc_partial_function doesn't use a minimal symbol and thus
1021 cache a bad endaddr. */
1022 for (pp
= psymtab
->objfile
->global_psymbols
.list
+ psymtab
->globals_offset
;
1023 (pp
- (psymtab
->objfile
->global_psymbols
.list
+ psymtab
->globals_offset
)
1024 < psymtab
->n_global_syms
);
1028 if (SYMBOL_DOMAIN (p
) == VAR_DOMAIN
1029 && SYMBOL_CLASS (p
) == LOC_BLOCK
1030 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
1031 && (SYMBOL_VALUE_ADDRESS (p
) > best_pc
1032 || (psymtab
->textlow
== 0
1033 && best_pc
== 0 && SYMBOL_VALUE_ADDRESS (p
) == 0)))
1035 if (section
) /* match on a specific section */
1037 fixup_psymbol_section (p
, psymtab
->objfile
);
1038 if (!matching_obj_sections (SYMBOL_OBJ_SECTION (p
), section
))
1041 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
1046 for (pp
= psymtab
->objfile
->static_psymbols
.list
+ psymtab
->statics_offset
;
1047 (pp
- (psymtab
->objfile
->static_psymbols
.list
+ psymtab
->statics_offset
)
1048 < psymtab
->n_static_syms
);
1052 if (SYMBOL_DOMAIN (p
) == VAR_DOMAIN
1053 && SYMBOL_CLASS (p
) == LOC_BLOCK
1054 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
1055 && (SYMBOL_VALUE_ADDRESS (p
) > best_pc
1056 || (psymtab
->textlow
== 0
1057 && best_pc
== 0 && SYMBOL_VALUE_ADDRESS (p
) == 0)))
1059 if (section
) /* match on a specific section */
1061 fixup_psymbol_section (p
, psymtab
->objfile
);
1062 if (!matching_obj_sections (SYMBOL_OBJ_SECTION (p
), section
))
1065 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
1073 /* Find which partial symbol within a psymtab matches PC. Return 0 if none.
1074 Check all psymtabs if PSYMTAB is 0. Backwards compatibility, no section. */
1076 struct partial_symbol
*
1077 find_pc_psymbol (struct partial_symtab
*psymtab
, CORE_ADDR pc
)
1079 return find_pc_sect_psymbol (psymtab
, pc
, find_pc_mapped_section (pc
));
1082 /* Debug symbols usually don't have section information. We need to dig that
1083 out of the minimal symbols and stash that in the debug symbol. */
1086 fixup_section (struct general_symbol_info
*ginfo
,
1087 CORE_ADDR addr
, struct objfile
*objfile
)
1089 struct minimal_symbol
*msym
;
1091 /* First, check whether a minimal symbol with the same name exists
1092 and points to the same address. The address check is required
1093 e.g. on PowerPC64, where the minimal symbol for a function will
1094 point to the function descriptor, while the debug symbol will
1095 point to the actual function code. */
1096 msym
= lookup_minimal_symbol_by_pc_name (addr
, ginfo
->name
, objfile
);
1099 ginfo
->obj_section
= SYMBOL_OBJ_SECTION (msym
);
1100 ginfo
->section
= SYMBOL_SECTION (msym
);
1104 /* Static, function-local variables do appear in the linker
1105 (minimal) symbols, but are frequently given names that won't
1106 be found via lookup_minimal_symbol(). E.g., it has been
1107 observed in frv-uclinux (ELF) executables that a static,
1108 function-local variable named "foo" might appear in the
1109 linker symbols as "foo.6" or "foo.3". Thus, there is no
1110 point in attempting to extend the lookup-by-name mechanism to
1111 handle this case due to the fact that there can be multiple
1114 So, instead, search the section table when lookup by name has
1115 failed. The ``addr'' and ``endaddr'' fields may have already
1116 been relocated. If so, the relocation offset (i.e. the
1117 ANOFFSET value) needs to be subtracted from these values when
1118 performing the comparison. We unconditionally subtract it,
1119 because, when no relocation has been performed, the ANOFFSET
1120 value will simply be zero.
1122 The address of the symbol whose section we're fixing up HAS
1123 NOT BEEN adjusted (relocated) yet. It can't have been since
1124 the section isn't yet known and knowing the section is
1125 necessary in order to add the correct relocation value. In
1126 other words, we wouldn't even be in this function (attempting
1127 to compute the section) if it were already known.
1129 Note that it is possible to search the minimal symbols
1130 (subtracting the relocation value if necessary) to find the
1131 matching minimal symbol, but this is overkill and much less
1132 efficient. It is not necessary to find the matching minimal
1133 symbol, only its section.
1135 Note that this technique (of doing a section table search)
1136 can fail when unrelocated section addresses overlap. For
1137 this reason, we still attempt a lookup by name prior to doing
1138 a search of the section table. */
1140 struct obj_section
*s
;
1141 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1143 int idx
= s
->the_bfd_section
->index
;
1144 CORE_ADDR offset
= ANOFFSET (objfile
->section_offsets
, idx
);
1146 if (obj_section_addr (s
) - offset
<= addr
1147 && addr
< obj_section_endaddr (s
) - offset
)
1149 ginfo
->obj_section
= s
;
1150 ginfo
->section
= idx
;
1158 fixup_symbol_section (struct symbol
*sym
, struct objfile
*objfile
)
1165 if (SYMBOL_OBJ_SECTION (sym
))
1168 /* We either have an OBJFILE, or we can get at it from the sym's
1169 symtab. Anything else is a bug. */
1170 gdb_assert (objfile
|| SYMBOL_SYMTAB (sym
));
1172 if (objfile
== NULL
)
1173 objfile
= SYMBOL_SYMTAB (sym
)->objfile
;
1175 /* We should have an objfile by now. */
1176 gdb_assert (objfile
);
1178 switch (SYMBOL_CLASS (sym
))
1182 addr
= SYMBOL_VALUE_ADDRESS (sym
);
1185 addr
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
1189 /* Nothing else will be listed in the minsyms -- no use looking
1194 fixup_section (&sym
->ginfo
, addr
, objfile
);
1199 struct partial_symbol
*
1200 fixup_psymbol_section (struct partial_symbol
*psym
, struct objfile
*objfile
)
1207 if (SYMBOL_OBJ_SECTION (psym
))
1210 gdb_assert (objfile
);
1212 switch (SYMBOL_CLASS (psym
))
1217 addr
= SYMBOL_VALUE_ADDRESS (psym
);
1220 /* Nothing else will be listed in the minsyms -- no use looking
1225 fixup_section (&psym
->ginfo
, addr
, objfile
);
1230 /* Find the definition for a specified symbol name NAME
1231 in domain DOMAIN, visible from lexical block BLOCK.
1232 Returns the struct symbol pointer, or zero if no symbol is found.
1233 C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
1234 NAME is a field of the current implied argument `this'. If so set
1235 *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
1236 BLOCK_FOUND is set to the block in which NAME is found (in the case of
1237 a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
1239 /* This function has a bunch of loops in it and it would seem to be
1240 attractive to put in some QUIT's (though I'm not really sure
1241 whether it can run long enough to be really important). But there
1242 are a few calls for which it would appear to be bad news to quit
1243 out of here: find_proc_desc in alpha-tdep.c and mips-tdep.c. (Note
1244 that there is C++ code below which can error(), but that probably
1245 doesn't affect these calls since they are looking for a known
1246 variable and thus can probably assume it will never hit the C++
1250 lookup_symbol_in_language (const char *name
, const struct block
*block
,
1251 const domain_enum domain
, enum language lang
,
1252 int *is_a_field_of_this
)
1254 char *demangled_name
= NULL
;
1255 const char *modified_name
= NULL
;
1256 struct symbol
*returnval
;
1257 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, 0);
1259 modified_name
= name
;
1261 /* If we are using C++ or Java, demangle the name before doing a lookup, so
1262 we can always binary search. */
1263 if (lang
== language_cplus
)
1265 demangled_name
= cplus_demangle (name
, DMGL_ANSI
| DMGL_PARAMS
);
1268 modified_name
= demangled_name
;
1269 make_cleanup (xfree
, demangled_name
);
1273 /* If we were given a non-mangled name, canonicalize it
1274 according to the language (so far only for C++). */
1275 demangled_name
= cp_canonicalize_string (name
);
1278 modified_name
= demangled_name
;
1279 make_cleanup (xfree
, demangled_name
);
1283 else if (lang
== language_java
)
1285 demangled_name
= cplus_demangle (name
,
1286 DMGL_ANSI
| DMGL_PARAMS
| DMGL_JAVA
);
1289 modified_name
= demangled_name
;
1290 make_cleanup (xfree
, demangled_name
);
1294 if (case_sensitivity
== case_sensitive_off
)
1299 len
= strlen (name
);
1300 copy
= (char *) alloca (len
+ 1);
1301 for (i
= 0; i
< len
; i
++)
1302 copy
[i
] = tolower (name
[i
]);
1304 modified_name
= copy
;
1307 returnval
= lookup_symbol_aux (modified_name
, block
, domain
, lang
,
1308 is_a_field_of_this
);
1309 do_cleanups (cleanup
);
1314 /* Behave like lookup_symbol_in_language, but performed with the
1315 current language. */
1318 lookup_symbol (const char *name
, const struct block
*block
,
1319 domain_enum domain
, int *is_a_field_of_this
)
1321 return lookup_symbol_in_language (name
, block
, domain
,
1322 current_language
->la_language
,
1323 is_a_field_of_this
);
1326 /* Behave like lookup_symbol except that NAME is the natural name
1327 of the symbol that we're looking for and, if LINKAGE_NAME is
1328 non-NULL, ensure that the symbol's linkage name matches as
1331 static struct symbol
*
1332 lookup_symbol_aux (const char *name
, const struct block
*block
,
1333 const domain_enum domain
, enum language language
,
1334 int *is_a_field_of_this
)
1337 const struct language_defn
*langdef
;
1339 /* Make sure we do something sensible with is_a_field_of_this, since
1340 the callers that set this parameter to some non-null value will
1341 certainly use it later and expect it to be either 0 or 1.
1342 If we don't set it, the contents of is_a_field_of_this are
1344 if (is_a_field_of_this
!= NULL
)
1345 *is_a_field_of_this
= 0;
1347 /* Search specified block and its superiors. Don't search
1348 STATIC_BLOCK or GLOBAL_BLOCK. */
1350 sym
= lookup_symbol_aux_local (name
, block
, domain
);
1354 /* If requested to do so by the caller and if appropriate for LANGUAGE,
1355 check to see if NAME is a field of `this'. */
1357 langdef
= language_def (language
);
1359 if (langdef
->la_name_of_this
!= NULL
&& is_a_field_of_this
!= NULL
1362 struct symbol
*sym
= NULL
;
1363 const struct block
*function_block
= block
;
1364 /* 'this' is only defined in the function's block, so find the
1365 enclosing function block. */
1366 for (; function_block
&& !BLOCK_FUNCTION (function_block
);
1367 function_block
= BLOCK_SUPERBLOCK (function_block
));
1369 if (function_block
&& !dict_empty (BLOCK_DICT (function_block
)))
1370 sym
= lookup_block_symbol (function_block
, langdef
->la_name_of_this
,
1374 struct type
*t
= sym
->type
;
1376 /* I'm not really sure that type of this can ever
1377 be typedefed; just be safe. */
1379 if (TYPE_CODE (t
) == TYPE_CODE_PTR
1380 || TYPE_CODE (t
) == TYPE_CODE_REF
)
1381 t
= TYPE_TARGET_TYPE (t
);
1383 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
1384 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1385 error (_("Internal error: `%s' is not an aggregate"),
1386 langdef
->la_name_of_this
);
1388 if (check_field (t
, name
))
1390 *is_a_field_of_this
= 1;
1396 /* Now do whatever is appropriate for LANGUAGE to look
1397 up static and global variables. */
1399 sym
= langdef
->la_lookup_symbol_nonlocal (name
, block
, domain
);
1403 /* Now search all static file-level symbols. Not strictly correct,
1404 but more useful than an error. Do the symtabs first, then check
1405 the psymtabs. If a psymtab indicates the existence of the
1406 desired name as a file-level static, then do psymtab-to-symtab
1407 conversion on the fly and return the found symbol. */
1409 sym
= lookup_symbol_aux_symtabs (STATIC_BLOCK
, name
, domain
);
1413 sym
= lookup_symbol_aux_psymtabs (STATIC_BLOCK
, name
, domain
);
1420 /* Check to see if the symbol is defined in BLOCK or its superiors.
1421 Don't search STATIC_BLOCK or GLOBAL_BLOCK. */
1423 static struct symbol
*
1424 lookup_symbol_aux_local (const char *name
, const struct block
*block
,
1425 const domain_enum domain
)
1428 const struct block
*static_block
= block_static_block (block
);
1430 /* Check if either no block is specified or it's a global block. */
1432 if (static_block
== NULL
)
1435 while (block
!= static_block
)
1437 sym
= lookup_symbol_aux_block (name
, block
, domain
);
1441 if (BLOCK_FUNCTION (block
) != NULL
&& block_inlined_p (block
))
1443 block
= BLOCK_SUPERBLOCK (block
);
1446 /* We've reached the edge of the function without finding a result. */
1451 /* Look up OBJFILE to BLOCK. */
1453 static struct objfile
*
1454 lookup_objfile_from_block (const struct block
*block
)
1456 struct objfile
*obj
;
1462 block
= block_global_block (block
);
1463 /* Go through SYMTABS. */
1464 ALL_SYMTABS (obj
, s
)
1465 if (block
== BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
))
1467 if (obj
->separate_debug_objfile_backlink
)
1468 obj
= obj
->separate_debug_objfile_backlink
;
1476 /* Look up a symbol in a block; if found, fixup the symbol, and set
1477 block_found appropriately. */
1480 lookup_symbol_aux_block (const char *name
, const struct block
*block
,
1481 const domain_enum domain
)
1485 sym
= lookup_block_symbol (block
, name
, domain
);
1488 block_found
= block
;
1489 return fixup_symbol_section (sym
, NULL
);
1495 /* Check all global symbols in OBJFILE in symtabs and
1499 lookup_global_symbol_from_objfile (const struct objfile
*main_objfile
,
1501 const domain_enum domain
)
1503 const struct objfile
*objfile
;
1505 struct blockvector
*bv
;
1506 const struct block
*block
;
1508 struct partial_symtab
*ps
;
1510 for (objfile
= main_objfile
;
1512 objfile
= objfile_separate_debug_iterate (main_objfile
, objfile
))
1514 /* Go through symtabs. */
1515 ALL_OBJFILE_SYMTABS (objfile
, s
)
1517 bv
= BLOCKVECTOR (s
);
1518 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1519 sym
= lookup_block_symbol (block
, name
, domain
);
1522 block_found
= block
;
1523 return fixup_symbol_section (sym
, (struct objfile
*)objfile
);
1527 /* Now go through psymtabs. */
1528 ALL_OBJFILE_PSYMTABS (objfile
, ps
)
1531 && lookup_partial_symbol (ps
, name
, 1, domain
))
1533 s
= PSYMTAB_TO_SYMTAB (ps
);
1534 bv
= BLOCKVECTOR (s
);
1535 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1536 sym
= lookup_block_symbol (block
, name
, domain
);
1537 return fixup_symbol_section (sym
, (struct objfile
*)objfile
);
1545 /* Check to see if the symbol is defined in one of the symtabs.
1546 BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
1547 depending on whether or not we want to search global symbols or
1550 static struct symbol
*
1551 lookup_symbol_aux_symtabs (int block_index
, const char *name
,
1552 const domain_enum domain
)
1555 struct objfile
*objfile
;
1556 struct blockvector
*bv
;
1557 const struct block
*block
;
1560 ALL_PRIMARY_SYMTABS (objfile
, s
)
1562 bv
= BLOCKVECTOR (s
);
1563 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
1564 sym
= lookup_block_symbol (block
, name
, domain
);
1567 block_found
= block
;
1568 return fixup_symbol_section (sym
, objfile
);
1575 /* Check to see if the symbol is defined in one of the partial
1576 symtabs. BLOCK_INDEX should be either GLOBAL_BLOCK or
1577 STATIC_BLOCK, depending on whether or not we want to search global
1578 symbols or static symbols. */
1580 static struct symbol
*
1581 lookup_symbol_aux_psymtabs (int block_index
, const char *name
,
1582 const domain_enum domain
)
1585 struct objfile
*objfile
;
1586 struct blockvector
*bv
;
1587 const struct block
*block
;
1588 struct partial_symtab
*ps
;
1590 const int psymtab_index
= (block_index
== GLOBAL_BLOCK
? 1 : 0);
1592 ALL_PSYMTABS (objfile
, ps
)
1595 && lookup_partial_symbol (ps
, name
, psymtab_index
, domain
))
1597 s
= PSYMTAB_TO_SYMTAB (ps
);
1598 bv
= BLOCKVECTOR (s
);
1599 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
1600 sym
= lookup_block_symbol (block
, name
, domain
);
1603 /* This shouldn't be necessary, but as a last resort try
1604 looking in the statics even though the psymtab claimed
1605 the symbol was global, or vice-versa. It's possible
1606 that the psymtab gets it wrong in some cases. */
1608 /* FIXME: carlton/2002-09-30: Should we really do that?
1609 If that happens, isn't it likely to be a GDB error, in
1610 which case we should fix the GDB error rather than
1611 silently dealing with it here? So I'd vote for
1612 removing the check for the symbol in the other
1614 block
= BLOCKVECTOR_BLOCK (bv
,
1615 block_index
== GLOBAL_BLOCK
?
1616 STATIC_BLOCK
: GLOBAL_BLOCK
);
1617 sym
= lookup_block_symbol (block
, name
, domain
);
1619 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>)."),
1620 block_index
== GLOBAL_BLOCK
? "global" : "static",
1621 name
, ps
->filename
, name
, name
);
1623 return fixup_symbol_section (sym
, objfile
);
1630 /* A default version of lookup_symbol_nonlocal for use by languages
1631 that can't think of anything better to do. This implements the C
1635 basic_lookup_symbol_nonlocal (const char *name
,
1636 const struct block
*block
,
1637 const domain_enum domain
)
1641 /* NOTE: carlton/2003-05-19: The comments below were written when
1642 this (or what turned into this) was part of lookup_symbol_aux;
1643 I'm much less worried about these questions now, since these
1644 decisions have turned out well, but I leave these comments here
1647 /* NOTE: carlton/2002-12-05: There is a question as to whether or
1648 not it would be appropriate to search the current global block
1649 here as well. (That's what this code used to do before the
1650 is_a_field_of_this check was moved up.) On the one hand, it's
1651 redundant with the lookup_symbol_aux_symtabs search that happens
1652 next. On the other hand, if decode_line_1 is passed an argument
1653 like filename:var, then the user presumably wants 'var' to be
1654 searched for in filename. On the third hand, there shouldn't be
1655 multiple global variables all of which are named 'var', and it's
1656 not like decode_line_1 has ever restricted its search to only
1657 global variables in a single filename. All in all, only
1658 searching the static block here seems best: it's correct and it's
1661 /* NOTE: carlton/2002-12-05: There's also a possible performance
1662 issue here: if you usually search for global symbols in the
1663 current file, then it would be slightly better to search the
1664 current global block before searching all the symtabs. But there
1665 are other factors that have a much greater effect on performance
1666 than that one, so I don't think we should worry about that for
1669 sym
= lookup_symbol_static (name
, block
, domain
);
1673 return lookup_symbol_global (name
, block
, domain
);
1676 /* Lookup a symbol in the static block associated to BLOCK, if there
1677 is one; do nothing if BLOCK is NULL or a global block. */
1680 lookup_symbol_static (const char *name
,
1681 const struct block
*block
,
1682 const domain_enum domain
)
1684 const struct block
*static_block
= block_static_block (block
);
1686 if (static_block
!= NULL
)
1687 return lookup_symbol_aux_block (name
, static_block
, domain
);
1692 /* Lookup a symbol in all files' global blocks (searching psymtabs if
1696 lookup_symbol_global (const char *name
,
1697 const struct block
*block
,
1698 const domain_enum domain
)
1700 struct symbol
*sym
= NULL
;
1701 struct objfile
*objfile
= NULL
;
1703 /* Call library-specific lookup procedure. */
1704 objfile
= lookup_objfile_from_block (block
);
1705 if (objfile
!= NULL
)
1706 sym
= solib_global_lookup (objfile
, name
, domain
);
1710 sym
= lookup_symbol_aux_symtabs (GLOBAL_BLOCK
, name
, domain
);
1714 return lookup_symbol_aux_psymtabs (GLOBAL_BLOCK
, name
, domain
);
1718 symbol_matches_domain (enum language symbol_language
,
1719 domain_enum symbol_domain
,
1722 /* For C++ "struct foo { ... }" also defines a typedef for "foo".
1723 A Java class declaration also defines a typedef for the class.
1724 Similarly, any Ada type declaration implicitly defines a typedef. */
1725 if (symbol_language
== language_cplus
1726 || symbol_language
== language_java
1727 || symbol_language
== language_ada
)
1729 if ((domain
== VAR_DOMAIN
|| domain
== STRUCT_DOMAIN
)
1730 && symbol_domain
== STRUCT_DOMAIN
)
1733 /* For all other languages, strict match is required. */
1734 return (symbol_domain
== domain
);
1737 /* Look, in partial_symtab PST, for symbol whose natural name is NAME.
1738 Check the global symbols if GLOBAL, the static symbols if not. */
1740 struct partial_symbol
*
1741 lookup_partial_symbol (struct partial_symtab
*pst
, const char *name
,
1742 int global
, domain_enum domain
)
1744 struct partial_symbol
*temp
;
1745 struct partial_symbol
**start
, **psym
;
1746 struct partial_symbol
**top
, **real_top
, **bottom
, **center
;
1747 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
1748 int do_linear_search
= 1;
1755 pst
->objfile
->global_psymbols
.list
+ pst
->globals_offset
:
1756 pst
->objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1758 if (global
) /* This means we can use a binary search. */
1760 do_linear_search
= 0;
1762 /* Binary search. This search is guaranteed to end with center
1763 pointing at the earliest partial symbol whose name might be
1764 correct. At that point *all* partial symbols with an
1765 appropriate name will be checked against the correct
1769 top
= start
+ length
- 1;
1771 while (top
> bottom
)
1773 center
= bottom
+ (top
- bottom
) / 2;
1774 if (!(center
< top
))
1775 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
1776 if (!do_linear_search
1777 && (SYMBOL_LANGUAGE (*center
) == language_java
))
1779 do_linear_search
= 1;
1781 if (strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*center
), name
) >= 0)
1787 bottom
= center
+ 1;
1790 if (!(top
== bottom
))
1791 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
1793 while (top
<= real_top
1794 && SYMBOL_MATCHES_SEARCH_NAME (*top
, name
))
1796 if (symbol_matches_domain (SYMBOL_LANGUAGE (*top
),
1797 SYMBOL_DOMAIN (*top
), domain
))
1803 /* Can't use a binary search or else we found during the binary search that
1804 we should also do a linear search. */
1806 if (do_linear_search
)
1808 for (psym
= start
; psym
< start
+ length
; psym
++)
1810 if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym
),
1811 SYMBOL_DOMAIN (*psym
), domain
)
1812 && SYMBOL_MATCHES_SEARCH_NAME (*psym
, name
))
1820 /* Look up a type named NAME in the struct_domain. The type returned
1821 must not be opaque -- i.e., must have at least one field
1825 lookup_transparent_type (const char *name
)
1827 return current_language
->la_lookup_transparent_type (name
);
1830 /* The standard implementation of lookup_transparent_type. This code
1831 was modeled on lookup_symbol -- the parts not relevant to looking
1832 up types were just left out. In particular it's assumed here that
1833 types are available in struct_domain and only at file-static or
1837 basic_lookup_transparent_type (const char *name
)
1840 struct symtab
*s
= NULL
;
1841 struct partial_symtab
*ps
;
1842 struct blockvector
*bv
;
1843 struct objfile
*objfile
;
1844 struct block
*block
;
1846 /* Now search all the global symbols. Do the symtab's first, then
1847 check the psymtab's. If a psymtab indicates the existence
1848 of the desired name as a global, then do psymtab-to-symtab
1849 conversion on the fly and return the found symbol. */
1851 ALL_PRIMARY_SYMTABS (objfile
, s
)
1853 bv
= BLOCKVECTOR (s
);
1854 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1855 sym
= lookup_block_symbol (block
, name
, STRUCT_DOMAIN
);
1856 if (sym
&& !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1858 return SYMBOL_TYPE (sym
);
1862 ALL_PSYMTABS (objfile
, ps
)
1864 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 1, STRUCT_DOMAIN
))
1866 s
= PSYMTAB_TO_SYMTAB (ps
);
1867 bv
= BLOCKVECTOR (s
);
1868 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1869 sym
= lookup_block_symbol (block
, name
, STRUCT_DOMAIN
);
1872 /* This shouldn't be necessary, but as a last resort
1873 * try looking in the statics even though the psymtab
1874 * claimed the symbol was global. It's possible that
1875 * the psymtab gets it wrong in some cases.
1877 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1878 sym
= lookup_block_symbol (block
, name
, STRUCT_DOMAIN
);
1880 error (_("Internal: global symbol `%s' found in %s psymtab but not in symtab.\n\
1881 %s may be an inlined function, or may be a template function\n\
1882 (if a template, try specifying an instantiation: %s<type>)."),
1883 name
, ps
->filename
, name
, name
);
1885 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1886 return SYMBOL_TYPE (sym
);
1890 /* Now search the static file-level symbols.
1891 Not strictly correct, but more useful than an error.
1892 Do the symtab's first, then
1893 check the psymtab's. If a psymtab indicates the existence
1894 of the desired name as a file-level static, then do psymtab-to-symtab
1895 conversion on the fly and return the found symbol.
1898 ALL_PRIMARY_SYMTABS (objfile
, s
)
1900 bv
= BLOCKVECTOR (s
);
1901 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1902 sym
= lookup_block_symbol (block
, name
, STRUCT_DOMAIN
);
1903 if (sym
&& !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1905 return SYMBOL_TYPE (sym
);
1909 ALL_PSYMTABS (objfile
, ps
)
1911 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 0, STRUCT_DOMAIN
))
1913 s
= PSYMTAB_TO_SYMTAB (ps
);
1914 bv
= BLOCKVECTOR (s
);
1915 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1916 sym
= lookup_block_symbol (block
, name
, STRUCT_DOMAIN
);
1919 /* This shouldn't be necessary, but as a last resort
1920 * try looking in the globals even though the psymtab
1921 * claimed the symbol was static. It's possible that
1922 * the psymtab gets it wrong in some cases.
1924 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1925 sym
= lookup_block_symbol (block
, name
, STRUCT_DOMAIN
);
1927 error (_("Internal: static symbol `%s' found in %s psymtab but not in symtab.\n\
1928 %s may be an inlined function, or may be a template function\n\
1929 (if a template, try specifying an instantiation: %s<type>)."),
1930 name
, ps
->filename
, name
, name
);
1932 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1933 return SYMBOL_TYPE (sym
);
1936 return (struct type
*) 0;
1940 /* Find the psymtab containing main(). */
1941 /* FIXME: What about languages without main() or specially linked
1942 executables that have no main() ? */
1944 struct partial_symtab
*
1945 find_main_psymtab (void)
1947 struct partial_symtab
*pst
;
1948 struct objfile
*objfile
;
1950 ALL_PSYMTABS (objfile
, pst
)
1952 if (lookup_partial_symbol (pst
, main_name (), 1, VAR_DOMAIN
))
1960 /* Search BLOCK for symbol NAME in DOMAIN.
1962 Note that if NAME is the demangled form of a C++ symbol, we will fail
1963 to find a match during the binary search of the non-encoded names, but
1964 for now we don't worry about the slight inefficiency of looking for
1965 a match we'll never find, since it will go pretty quick. Once the
1966 binary search terminates, we drop through and do a straight linear
1967 search on the symbols. Each symbol which is marked as being a ObjC/C++
1968 symbol (language_cplus or language_objc set) has both the encoded and
1969 non-encoded names tested for a match.
1973 lookup_block_symbol (const struct block
*block
, const char *name
,
1974 const domain_enum domain
)
1976 struct dict_iterator iter
;
1979 if (!BLOCK_FUNCTION (block
))
1981 for (sym
= dict_iter_name_first (BLOCK_DICT (block
), name
, &iter
);
1983 sym
= dict_iter_name_next (name
, &iter
))
1985 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym
),
1986 SYMBOL_DOMAIN (sym
), domain
))
1993 /* Note that parameter symbols do not always show up last in the
1994 list; this loop makes sure to take anything else other than
1995 parameter symbols first; it only uses parameter symbols as a
1996 last resort. Note that this only takes up extra computation
1999 struct symbol
*sym_found
= NULL
;
2001 for (sym
= dict_iter_name_first (BLOCK_DICT (block
), name
, &iter
);
2003 sym
= dict_iter_name_next (name
, &iter
))
2005 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym
),
2006 SYMBOL_DOMAIN (sym
), domain
))
2009 if (!SYMBOL_IS_ARGUMENT (sym
))
2015 return (sym_found
); /* Will be NULL if not found. */
2019 /* Find the symtab associated with PC and SECTION. Look through the
2020 psymtabs and read in another symtab if necessary. */
2023 find_pc_sect_symtab (CORE_ADDR pc
, struct obj_section
*section
)
2026 struct blockvector
*bv
;
2027 struct symtab
*s
= NULL
;
2028 struct symtab
*best_s
= NULL
;
2029 struct partial_symtab
*ps
;
2030 struct objfile
*objfile
;
2031 struct program_space
*pspace
;
2032 CORE_ADDR distance
= 0;
2033 struct minimal_symbol
*msymbol
;
2035 pspace
= current_program_space
;
2037 /* If we know that this is not a text address, return failure. This is
2038 necessary because we loop based on the block's high and low code
2039 addresses, which do not include the data ranges, and because
2040 we call find_pc_sect_psymtab which has a similar restriction based
2041 on the partial_symtab's texthigh and textlow. */
2042 msymbol
= lookup_minimal_symbol_by_pc_section (pc
, section
);
2044 && (MSYMBOL_TYPE (msymbol
) == mst_data
2045 || MSYMBOL_TYPE (msymbol
) == mst_bss
2046 || MSYMBOL_TYPE (msymbol
) == mst_abs
2047 || MSYMBOL_TYPE (msymbol
) == mst_file_data
2048 || MSYMBOL_TYPE (msymbol
) == mst_file_bss
))
2051 /* Search all symtabs for the one whose file contains our address, and which
2052 is the smallest of all the ones containing the address. This is designed
2053 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
2054 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
2055 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
2057 This happens for native ecoff format, where code from included files
2058 gets its own symtab. The symtab for the included file should have
2059 been read in already via the dependency mechanism.
2060 It might be swifter to create several symtabs with the same name
2061 like xcoff does (I'm not sure).
2063 It also happens for objfiles that have their functions reordered.
2064 For these, the symtab we are looking for is not necessarily read in. */
2066 ALL_PRIMARY_SYMTABS (objfile
, s
)
2068 bv
= BLOCKVECTOR (s
);
2069 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
2071 if (BLOCK_START (b
) <= pc
2072 && BLOCK_END (b
) > pc
2074 || BLOCK_END (b
) - BLOCK_START (b
) < distance
))
2076 /* For an objfile that has its functions reordered,
2077 find_pc_psymtab will find the proper partial symbol table
2078 and we simply return its corresponding symtab. */
2079 /* In order to better support objfiles that contain both
2080 stabs and coff debugging info, we continue on if a psymtab
2082 if ((objfile
->flags
& OBJF_REORDERED
) && objfile
->psymtabs
)
2084 ps
= find_pc_sect_psymtab (pc
, section
);
2086 return PSYMTAB_TO_SYMTAB (ps
);
2090 struct dict_iterator iter
;
2091 struct symbol
*sym
= NULL
;
2093 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2095 fixup_symbol_section (sym
, objfile
);
2096 if (matching_obj_sections (SYMBOL_OBJ_SECTION (sym
), section
))
2100 continue; /* no symbol in this symtab matches section */
2102 distance
= BLOCK_END (b
) - BLOCK_START (b
);
2111 ps
= find_pc_sect_psymtab (pc
, section
);
2115 /* Might want to error() here (in case symtab is corrupt and
2116 will cause a core dump), but maybe we can successfully
2117 continue, so let's not. */
2119 (Internal error: pc %s in read in psymtab, but not in symtab.)\n"),
2120 paddress (get_objfile_arch (ps
->objfile
), pc
));
2121 s
= PSYMTAB_TO_SYMTAB (ps
);
2126 /* Find the symtab associated with PC. Look through the psymtabs and
2127 read in another symtab if necessary. Backward compatibility, no section */
2130 find_pc_symtab (CORE_ADDR pc
)
2132 return find_pc_sect_symtab (pc
, find_pc_mapped_section (pc
));
2136 /* Find the source file and line number for a given PC value and SECTION.
2137 Return a structure containing a symtab pointer, a line number,
2138 and a pc range for the entire source line.
2139 The value's .pc field is NOT the specified pc.
2140 NOTCURRENT nonzero means, if specified pc is on a line boundary,
2141 use the line that ends there. Otherwise, in that case, the line
2142 that begins there is used. */
2144 /* The big complication here is that a line may start in one file, and end just
2145 before the start of another file. This usually occurs when you #include
2146 code in the middle of a subroutine. To properly find the end of a line's PC
2147 range, we must search all symtabs associated with this compilation unit, and
2148 find the one whose first PC is closer than that of the next line in this
2151 /* If it's worth the effort, we could be using a binary search. */
2153 struct symtab_and_line
2154 find_pc_sect_line (CORE_ADDR pc
, struct obj_section
*section
, int notcurrent
)
2157 struct linetable
*l
;
2160 struct linetable_entry
*item
;
2161 struct symtab_and_line val
;
2162 struct blockvector
*bv
;
2163 struct minimal_symbol
*msymbol
;
2164 struct minimal_symbol
*mfunsym
;
2166 /* Info on best line seen so far, and where it starts, and its file. */
2168 struct linetable_entry
*best
= NULL
;
2169 CORE_ADDR best_end
= 0;
2170 struct symtab
*best_symtab
= 0;
2172 /* Store here the first line number
2173 of a file which contains the line at the smallest pc after PC.
2174 If we don't find a line whose range contains PC,
2175 we will use a line one less than this,
2176 with a range from the start of that file to the first line's pc. */
2177 struct linetable_entry
*alt
= NULL
;
2178 struct symtab
*alt_symtab
= 0;
2180 /* Info on best line seen in this file. */
2182 struct linetable_entry
*prev
;
2184 /* If this pc is not from the current frame,
2185 it is the address of the end of a call instruction.
2186 Quite likely that is the start of the following statement.
2187 But what we want is the statement containing the instruction.
2188 Fudge the pc to make sure we get that. */
2190 init_sal (&val
); /* initialize to zeroes */
2192 val
.pspace
= current_program_space
;
2194 /* It's tempting to assume that, if we can't find debugging info for
2195 any function enclosing PC, that we shouldn't search for line
2196 number info, either. However, GAS can emit line number info for
2197 assembly files --- very helpful when debugging hand-written
2198 assembly code. In such a case, we'd have no debug info for the
2199 function, but we would have line info. */
2204 /* elz: added this because this function returned the wrong
2205 information if the pc belongs to a stub (import/export)
2206 to call a shlib function. This stub would be anywhere between
2207 two functions in the target, and the line info was erroneously
2208 taken to be the one of the line before the pc.
2210 /* RT: Further explanation:
2212 * We have stubs (trampolines) inserted between procedures.
2214 * Example: "shr1" exists in a shared library, and a "shr1" stub also
2215 * exists in the main image.
2217 * In the minimal symbol table, we have a bunch of symbols
2218 * sorted by start address. The stubs are marked as "trampoline",
2219 * the others appear as text. E.g.:
2221 * Minimal symbol table for main image
2222 * main: code for main (text symbol)
2223 * shr1: stub (trampoline symbol)
2224 * foo: code for foo (text symbol)
2226 * Minimal symbol table for "shr1" image:
2228 * shr1: code for shr1 (text symbol)
2231 * So the code below is trying to detect if we are in the stub
2232 * ("shr1" stub), and if so, find the real code ("shr1" trampoline),
2233 * and if found, do the symbolization from the real-code address
2234 * rather than the stub address.
2236 * Assumptions being made about the minimal symbol table:
2237 * 1. lookup_minimal_symbol_by_pc() will return a trampoline only
2238 * if we're really in the trampoline. If we're beyond it (say
2239 * we're in "foo" in the above example), it'll have a closer
2240 * symbol (the "foo" text symbol for example) and will not
2241 * return the trampoline.
2242 * 2. lookup_minimal_symbol_text() will find a real text symbol
2243 * corresponding to the trampoline, and whose address will
2244 * be different than the trampoline address. I put in a sanity
2245 * check for the address being the same, to avoid an
2246 * infinite recursion.
2248 msymbol
= lookup_minimal_symbol_by_pc (pc
);
2249 if (msymbol
!= NULL
)
2250 if (MSYMBOL_TYPE (msymbol
) == mst_solib_trampoline
)
2252 mfunsym
= lookup_minimal_symbol_text (SYMBOL_LINKAGE_NAME (msymbol
),
2254 if (mfunsym
== NULL
)
2255 /* I eliminated this warning since it is coming out
2256 * in the following situation:
2257 * gdb shmain // test program with shared libraries
2258 * (gdb) break shr1 // function in shared lib
2259 * Warning: In stub for ...
2260 * In the above situation, the shared lib is not loaded yet,
2261 * so of course we can't find the real func/line info,
2262 * but the "break" still works, and the warning is annoying.
2263 * So I commented out the warning. RT */
2264 /* warning ("In stub for %s; unable to find real function/line info", SYMBOL_LINKAGE_NAME (msymbol)) */ ;
2266 else if (SYMBOL_VALUE_ADDRESS (mfunsym
) == SYMBOL_VALUE_ADDRESS (msymbol
))
2267 /* Avoid infinite recursion */
2268 /* See above comment about why warning is commented out */
2269 /* warning ("In stub for %s; unable to find real function/line info", SYMBOL_LINKAGE_NAME (msymbol)) */ ;
2272 return find_pc_line (SYMBOL_VALUE_ADDRESS (mfunsym
), 0);
2276 s
= find_pc_sect_symtab (pc
, section
);
2279 /* if no symbol information, return previous pc */
2286 bv
= BLOCKVECTOR (s
);
2288 /* Look at all the symtabs that share this blockvector.
2289 They all have the same apriori range, that we found was right;
2290 but they have different line tables. */
2292 for (; s
&& BLOCKVECTOR (s
) == bv
; s
= s
->next
)
2294 /* Find the best line in this symtab. */
2301 /* I think len can be zero if the symtab lacks line numbers
2302 (e.g. gcc -g1). (Either that or the LINETABLE is NULL;
2303 I'm not sure which, and maybe it depends on the symbol
2309 item
= l
->item
; /* Get first line info */
2311 /* Is this file's first line closer than the first lines of other files?
2312 If so, record this file, and its first line, as best alternate. */
2313 if (item
->pc
> pc
&& (!alt
|| item
->pc
< alt
->pc
))
2319 for (i
= 0; i
< len
; i
++, item
++)
2321 /* Leave prev pointing to the linetable entry for the last line
2322 that started at or before PC. */
2329 /* At this point, prev points at the line whose start addr is <= pc, and
2330 item points at the next line. If we ran off the end of the linetable
2331 (pc >= start of the last line), then prev == item. If pc < start of
2332 the first line, prev will not be set. */
2334 /* Is this file's best line closer than the best in the other files?
2335 If so, record this file, and its best line, as best so far. Don't
2336 save prev if it represents the end of a function (i.e. line number
2337 0) instead of a real line. */
2339 if (prev
&& prev
->line
&& (!best
|| prev
->pc
> best
->pc
))
2344 /* Discard BEST_END if it's before the PC of the current BEST. */
2345 if (best_end
<= best
->pc
)
2349 /* If another line (denoted by ITEM) is in the linetable and its
2350 PC is after BEST's PC, but before the current BEST_END, then
2351 use ITEM's PC as the new best_end. */
2352 if (best
&& i
< len
&& item
->pc
> best
->pc
2353 && (best_end
== 0 || best_end
> item
->pc
))
2354 best_end
= item
->pc
;
2359 /* If we didn't find any line number info, just return zeros.
2360 We used to return alt->line - 1 here, but that could be
2361 anywhere; if we don't have line number info for this PC,
2362 don't make some up. */
2365 else if (best
->line
== 0)
2367 /* If our best fit is in a range of PC's for which no line
2368 number info is available (line number is zero) then we didn't
2369 find any valid line information. */
2374 val
.symtab
= best_symtab
;
2375 val
.line
= best
->line
;
2377 if (best_end
&& (!alt
|| best_end
< alt
->pc
))
2382 val
.end
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
2384 val
.section
= section
;
2388 /* Backward compatibility (no section) */
2390 struct symtab_and_line
2391 find_pc_line (CORE_ADDR pc
, int notcurrent
)
2393 struct obj_section
*section
;
2395 section
= find_pc_overlay (pc
);
2396 if (pc_in_unmapped_range (pc
, section
))
2397 pc
= overlay_mapped_address (pc
, section
);
2398 return find_pc_sect_line (pc
, section
, notcurrent
);
2401 /* Find line number LINE in any symtab whose name is the same as
2404 If found, return the symtab that contains the linetable in which it was
2405 found, set *INDEX to the index in the linetable of the best entry
2406 found, and set *EXACT_MATCH nonzero if the value returned is an
2409 If not found, return NULL. */
2412 find_line_symtab (struct symtab
*symtab
, int line
, int *index
, int *exact_match
)
2414 int exact
= 0; /* Initialized here to avoid a compiler warning. */
2416 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
2420 struct linetable
*best_linetable
;
2421 struct symtab
*best_symtab
;
2423 /* First try looking it up in the given symtab. */
2424 best_linetable
= LINETABLE (symtab
);
2425 best_symtab
= symtab
;
2426 best_index
= find_line_common (best_linetable
, line
, &exact
);
2427 if (best_index
< 0 || !exact
)
2429 /* Didn't find an exact match. So we better keep looking for
2430 another symtab with the same name. In the case of xcoff,
2431 multiple csects for one source file (produced by IBM's FORTRAN
2432 compiler) produce multiple symtabs (this is unavoidable
2433 assuming csects can be at arbitrary places in memory and that
2434 the GLOBAL_BLOCK of a symtab has a begin and end address). */
2436 /* BEST is the smallest linenumber > LINE so far seen,
2437 or 0 if none has been seen so far.
2438 BEST_INDEX and BEST_LINETABLE identify the item for it. */
2441 struct objfile
*objfile
;
2443 struct partial_symtab
*p
;
2445 if (best_index
>= 0)
2446 best
= best_linetable
->item
[best_index
].line
;
2450 ALL_PSYMTABS (objfile
, p
)
2452 if (FILENAME_CMP (symtab
->filename
, p
->filename
) != 0)
2454 PSYMTAB_TO_SYMTAB (p
);
2457 /* Get symbol full file name if possible. */
2458 symtab_to_fullname (symtab
);
2460 ALL_SYMTABS (objfile
, s
)
2462 struct linetable
*l
;
2465 if (FILENAME_CMP (symtab
->filename
, s
->filename
) != 0)
2467 if (symtab
->fullname
!= NULL
2468 && symtab_to_fullname (s
) != NULL
2469 && FILENAME_CMP (symtab
->fullname
, s
->fullname
) != 0)
2472 ind
= find_line_common (l
, line
, &exact
);
2482 if (best
== 0 || l
->item
[ind
].line
< best
)
2484 best
= l
->item
[ind
].line
;
2497 *index
= best_index
;
2499 *exact_match
= exact
;
2504 /* Set the PC value for a given source file and line number and return true.
2505 Returns zero for invalid line number (and sets the PC to 0).
2506 The source file is specified with a struct symtab. */
2509 find_line_pc (struct symtab
*symtab
, int line
, CORE_ADDR
*pc
)
2511 struct linetable
*l
;
2518 symtab
= find_line_symtab (symtab
, line
, &ind
, NULL
);
2521 l
= LINETABLE (symtab
);
2522 *pc
= l
->item
[ind
].pc
;
2529 /* Find the range of pc values in a line.
2530 Store the starting pc of the line into *STARTPTR
2531 and the ending pc (start of next line) into *ENDPTR.
2532 Returns 1 to indicate success.
2533 Returns 0 if could not find the specified line. */
2536 find_line_pc_range (struct symtab_and_line sal
, CORE_ADDR
*startptr
,
2539 CORE_ADDR startaddr
;
2540 struct symtab_and_line found_sal
;
2543 if (startaddr
== 0 && !find_line_pc (sal
.symtab
, sal
.line
, &startaddr
))
2546 /* This whole function is based on address. For example, if line 10 has
2547 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
2548 "info line *0x123" should say the line goes from 0x100 to 0x200
2549 and "info line *0x355" should say the line goes from 0x300 to 0x400.
2550 This also insures that we never give a range like "starts at 0x134
2551 and ends at 0x12c". */
2553 found_sal
= find_pc_sect_line (startaddr
, sal
.section
, 0);
2554 if (found_sal
.line
!= sal
.line
)
2556 /* The specified line (sal) has zero bytes. */
2557 *startptr
= found_sal
.pc
;
2558 *endptr
= found_sal
.pc
;
2562 *startptr
= found_sal
.pc
;
2563 *endptr
= found_sal
.end
;
2568 /* Given a line table and a line number, return the index into the line
2569 table for the pc of the nearest line whose number is >= the specified one.
2570 Return -1 if none is found. The value is >= 0 if it is an index.
2572 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
2575 find_line_common (struct linetable
*l
, int lineno
,
2581 /* BEST is the smallest linenumber > LINENO so far seen,
2582 or 0 if none has been seen so far.
2583 BEST_INDEX identifies the item for it. */
2585 int best_index
= -1;
2596 for (i
= 0; i
< len
; i
++)
2598 struct linetable_entry
*item
= &(l
->item
[i
]);
2600 if (item
->line
== lineno
)
2602 /* Return the first (lowest address) entry which matches. */
2607 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
2614 /* If we got here, we didn't get an exact match. */
2619 find_pc_line_pc_range (CORE_ADDR pc
, CORE_ADDR
*startptr
, CORE_ADDR
*endptr
)
2621 struct symtab_and_line sal
;
2622 sal
= find_pc_line (pc
, 0);
2625 return sal
.symtab
!= 0;
2628 /* Given a function start address PC and SECTION, find the first
2629 address after the function prologue. */
2631 find_function_start_pc (struct gdbarch
*gdbarch
,
2632 CORE_ADDR pc
, struct obj_section
*section
)
2634 /* If the function is in an unmapped overlay, use its unmapped LMA address,
2635 so that gdbarch_skip_prologue has something unique to work on. */
2636 if (section_is_overlay (section
) && !section_is_mapped (section
))
2637 pc
= overlay_unmapped_address (pc
, section
);
2639 pc
+= gdbarch_deprecated_function_start_offset (gdbarch
);
2640 pc
= gdbarch_skip_prologue (gdbarch
, pc
);
2642 /* For overlays, map pc back into its mapped VMA range. */
2643 pc
= overlay_mapped_address (pc
, section
);
2648 /* Given a function start address FUNC_ADDR and SYMTAB, find the first
2649 address for that function that has an entry in SYMTAB's line info
2650 table. If such an entry cannot be found, return FUNC_ADDR
2653 skip_prologue_using_lineinfo (CORE_ADDR func_addr
, struct symtab
*symtab
)
2655 CORE_ADDR func_start
, func_end
;
2656 struct linetable
*l
;
2658 int best_lineno
= 0;
2659 CORE_ADDR best_pc
= func_addr
;
2661 /* Give up if this symbol has no lineinfo table. */
2662 l
= LINETABLE (symtab
);
2666 /* Get the range for the function's PC values, or give up if we
2667 cannot, for some reason. */
2668 if (!find_pc_partial_function (func_addr
, NULL
, &func_start
, &func_end
))
2671 /* Linetable entries are ordered by PC values, see the commentary in
2672 symtab.h where `struct linetable' is defined. Thus, the first
2673 entry whose PC is in the range [FUNC_START..FUNC_END[ is the
2674 address we are looking for. */
2675 for (i
= 0; i
< l
->nitems
; i
++)
2677 struct linetable_entry
*item
= &(l
->item
[i
]);
2679 /* Don't use line numbers of zero, they mark special entries in
2680 the table. See the commentary on symtab.h before the
2681 definition of struct linetable. */
2682 if (item
->line
> 0 && func_start
<= item
->pc
&& item
->pc
< func_end
)
2689 /* Given a function symbol SYM, find the symtab and line for the start
2691 If the argument FUNFIRSTLINE is nonzero, we want the first line
2692 of real code inside the function. */
2694 struct symtab_and_line
2695 find_function_start_sal (struct symbol
*sym
, int funfirstline
)
2697 struct block
*block
= SYMBOL_BLOCK_VALUE (sym
);
2698 struct objfile
*objfile
= lookup_objfile_from_block (block
);
2699 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2702 struct symtab_and_line sal
;
2703 struct block
*b
, *function_block
;
2705 struct cleanup
*old_chain
;
2707 old_chain
= save_current_space_and_thread ();
2708 switch_to_program_space_and_thread (objfile
->pspace
);
2710 pc
= BLOCK_START (block
);
2711 fixup_symbol_section (sym
, objfile
);
2714 /* Skip "first line" of function (which is actually its prologue). */
2715 pc
= find_function_start_pc (gdbarch
, pc
, SYMBOL_OBJ_SECTION (sym
));
2717 sal
= find_pc_sect_line (pc
, SYMBOL_OBJ_SECTION (sym
), 0);
2719 /* Check if gdbarch_skip_prologue left us in mid-line, and the next
2720 line is still part of the same function. */
2722 && BLOCK_START (block
) <= sal
.end
2723 && sal
.end
< BLOCK_END (block
))
2725 /* First pc of next line */
2727 /* Recalculate the line number (might not be N+1). */
2728 sal
= find_pc_sect_line (pc
, SYMBOL_OBJ_SECTION (sym
), 0);
2731 /* On targets with executable formats that don't have a concept of
2732 constructors (ELF with .init has, PE doesn't), gcc emits a call
2733 to `__main' in `main' between the prologue and before user
2736 && gdbarch_skip_main_prologue_p (gdbarch
)
2737 && SYMBOL_LINKAGE_NAME (sym
)
2738 && strcmp (SYMBOL_LINKAGE_NAME (sym
), "main") == 0)
2740 pc
= gdbarch_skip_main_prologue (gdbarch
, pc
);
2741 /* Recalculate the line number (might not be N+1). */
2742 sal
= find_pc_sect_line (pc
, SYMBOL_OBJ_SECTION (sym
), 0);
2745 /* If we still don't have a valid source line, try to find the first
2746 PC in the lineinfo table that belongs to the same function. This
2747 happens with COFF debug info, which does not seem to have an
2748 entry in lineinfo table for the code after the prologue which has
2749 no direct relation to source. For example, this was found to be
2750 the case with the DJGPP target using "gcc -gcoff" when the
2751 compiler inserted code after the prologue to make sure the stack
2753 if (funfirstline
&& sal
.symtab
== NULL
)
2755 pc
= skip_prologue_using_lineinfo (pc
, SYMBOL_SYMTAB (sym
));
2756 /* Recalculate the line number. */
2757 sal
= find_pc_sect_line (pc
, SYMBOL_OBJ_SECTION (sym
), 0);
2761 sal
.pspace
= objfile
->pspace
;
2763 /* Check if we are now inside an inlined function. If we can,
2764 use the call site of the function instead. */
2765 b
= block_for_pc_sect (sal
.pc
, SYMBOL_OBJ_SECTION (sym
));
2766 function_block
= NULL
;
2769 if (BLOCK_FUNCTION (b
) != NULL
&& block_inlined_p (b
))
2771 else if (BLOCK_FUNCTION (b
) != NULL
)
2773 b
= BLOCK_SUPERBLOCK (b
);
2775 if (function_block
!= NULL
2776 && SYMBOL_LINE (BLOCK_FUNCTION (function_block
)) != 0)
2778 sal
.line
= SYMBOL_LINE (BLOCK_FUNCTION (function_block
));
2779 sal
.symtab
= SYMBOL_SYMTAB (BLOCK_FUNCTION (function_block
));
2782 do_cleanups (old_chain
);
2786 /* If P is of the form "operator[ \t]+..." where `...' is
2787 some legitimate operator text, return a pointer to the
2788 beginning of the substring of the operator text.
2789 Otherwise, return "". */
2791 operator_chars (char *p
, char **end
)
2794 if (strncmp (p
, "operator", 8))
2798 /* Don't get faked out by `operator' being part of a longer
2800 if (isalpha (*p
) || *p
== '_' || *p
== '$' || *p
== '\0')
2803 /* Allow some whitespace between `operator' and the operator symbol. */
2804 while (*p
== ' ' || *p
== '\t')
2807 /* Recognize 'operator TYPENAME'. */
2809 if (isalpha (*p
) || *p
== '_' || *p
== '$')
2812 while (isalnum (*q
) || *q
== '_' || *q
== '$')
2821 case '\\': /* regexp quoting */
2824 if (p
[2] == '=') /* 'operator\*=' */
2826 else /* 'operator\*' */
2830 else if (p
[1] == '[')
2833 error (_("mismatched quoting on brackets, try 'operator\\[\\]'"));
2834 else if (p
[2] == '\\' && p
[3] == ']')
2836 *end
= p
+ 4; /* 'operator\[\]' */
2840 error (_("nothing is allowed between '[' and ']'"));
2844 /* Gratuitous qoute: skip it and move on. */
2866 if (p
[0] == '-' && p
[1] == '>')
2868 /* Struct pointer member operator 'operator->'. */
2871 *end
= p
+ 3; /* 'operator->*' */
2874 else if (p
[2] == '\\')
2876 *end
= p
+ 4; /* Hopefully 'operator->\*' */
2881 *end
= p
+ 2; /* 'operator->' */
2885 if (p
[1] == '=' || p
[1] == p
[0])
2896 error (_("`operator ()' must be specified without whitespace in `()'"));
2901 error (_("`operator ?:' must be specified without whitespace in `?:'"));
2906 error (_("`operator []' must be specified without whitespace in `[]'"));
2910 error (_("`operator %s' not supported"), p
);
2919 /* If FILE is not already in the table of files, return zero;
2920 otherwise return non-zero. Optionally add FILE to the table if ADD
2921 is non-zero. If *FIRST is non-zero, forget the old table
2924 filename_seen (const char *file
, int add
, int *first
)
2926 /* Table of files seen so far. */
2927 static const char **tab
= NULL
;
2928 /* Allocated size of tab in elements.
2929 Start with one 256-byte block (when using GNU malloc.c).
2930 24 is the malloc overhead when range checking is in effect. */
2931 static int tab_alloc_size
= (256 - 24) / sizeof (char *);
2932 /* Current size of tab in elements. */
2933 static int tab_cur_size
;
2939 tab
= (const char **) xmalloc (tab_alloc_size
* sizeof (*tab
));
2943 /* Is FILE in tab? */
2944 for (p
= tab
; p
< tab
+ tab_cur_size
; p
++)
2945 if (strcmp (*p
, file
) == 0)
2948 /* No; maybe add it to tab. */
2951 if (tab_cur_size
== tab_alloc_size
)
2953 tab_alloc_size
*= 2;
2954 tab
= (const char **) xrealloc ((char *) tab
,
2955 tab_alloc_size
* sizeof (*tab
));
2957 tab
[tab_cur_size
++] = file
;
2963 /* Slave routine for sources_info. Force line breaks at ,'s.
2964 NAME is the name to print and *FIRST is nonzero if this is the first
2965 name printed. Set *FIRST to zero. */
2967 output_source_filename (const char *name
, int *first
)
2969 /* Since a single source file can result in several partial symbol
2970 tables, we need to avoid printing it more than once. Note: if
2971 some of the psymtabs are read in and some are not, it gets
2972 printed both under "Source files for which symbols have been
2973 read" and "Source files for which symbols will be read in on
2974 demand". I consider this a reasonable way to deal with the
2975 situation. I'm not sure whether this can also happen for
2976 symtabs; it doesn't hurt to check. */
2978 /* Was NAME already seen? */
2979 if (filename_seen (name
, 1, first
))
2981 /* Yes; don't print it again. */
2984 /* No; print it and reset *FIRST. */
2991 printf_filtered (", ");
2995 fputs_filtered (name
, gdb_stdout
);
2999 sources_info (char *ignore
, int from_tty
)
3002 struct partial_symtab
*ps
;
3003 struct objfile
*objfile
;
3006 if (!have_full_symbols () && !have_partial_symbols ())
3008 error (_("No symbol table is loaded. Use the \"file\" command."));
3011 printf_filtered ("Source files for which symbols have been read in:\n\n");
3014 ALL_SYMTABS (objfile
, s
)
3016 const char *fullname
= symtab_to_fullname (s
);
3017 output_source_filename (fullname
? fullname
: s
->filename
, &first
);
3019 printf_filtered ("\n\n");
3021 printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
3024 ALL_PSYMTABS (objfile
, ps
)
3028 const char *fullname
= psymtab_to_fullname (ps
);
3029 output_source_filename (fullname
? fullname
: ps
->filename
, &first
);
3032 printf_filtered ("\n");
3036 file_matches (char *file
, char *files
[], int nfiles
)
3040 if (file
!= NULL
&& nfiles
!= 0)
3042 for (i
= 0; i
< nfiles
; i
++)
3044 if (strcmp (files
[i
], lbasename (file
)) == 0)
3048 else if (nfiles
== 0)
3053 /* Free any memory associated with a search. */
3055 free_search_symbols (struct symbol_search
*symbols
)
3057 struct symbol_search
*p
;
3058 struct symbol_search
*next
;
3060 for (p
= symbols
; p
!= NULL
; p
= next
)
3068 do_free_search_symbols_cleanup (void *symbols
)
3070 free_search_symbols (symbols
);
3074 make_cleanup_free_search_symbols (struct symbol_search
*symbols
)
3076 return make_cleanup (do_free_search_symbols_cleanup
, symbols
);
3079 /* Helper function for sort_search_symbols and qsort. Can only
3080 sort symbols, not minimal symbols. */
3082 compare_search_syms (const void *sa
, const void *sb
)
3084 struct symbol_search
**sym_a
= (struct symbol_search
**) sa
;
3085 struct symbol_search
**sym_b
= (struct symbol_search
**) sb
;
3087 return strcmp (SYMBOL_PRINT_NAME ((*sym_a
)->symbol
),
3088 SYMBOL_PRINT_NAME ((*sym_b
)->symbol
));
3091 /* Sort the ``nfound'' symbols in the list after prevtail. Leave
3092 prevtail where it is, but update its next pointer to point to
3093 the first of the sorted symbols. */
3094 static struct symbol_search
*
3095 sort_search_symbols (struct symbol_search
*prevtail
, int nfound
)
3097 struct symbol_search
**symbols
, *symp
, *old_next
;
3100 symbols
= (struct symbol_search
**) xmalloc (sizeof (struct symbol_search
*)
3102 symp
= prevtail
->next
;
3103 for (i
= 0; i
< nfound
; i
++)
3108 /* Generally NULL. */
3111 qsort (symbols
, nfound
, sizeof (struct symbol_search
*),
3112 compare_search_syms
);
3115 for (i
= 0; i
< nfound
; i
++)
3117 symp
->next
= symbols
[i
];
3120 symp
->next
= old_next
;
3126 /* Search the symbol table for matches to the regular expression REGEXP,
3127 returning the results in *MATCHES.
3129 Only symbols of KIND are searched:
3130 FUNCTIONS_DOMAIN - search all functions
3131 TYPES_DOMAIN - search all type names
3132 VARIABLES_DOMAIN - search all symbols, excluding functions, type names,
3133 and constants (enums)
3135 free_search_symbols should be called when *MATCHES is no longer needed.
3137 The results are sorted locally; each symtab's global and static blocks are
3138 separately alphabetized.
3141 search_symbols (char *regexp
, domain_enum kind
, int nfiles
, char *files
[],
3142 struct symbol_search
**matches
)
3145 struct partial_symtab
*ps
;
3146 struct blockvector
*bv
;
3149 struct dict_iterator iter
;
3151 struct partial_symbol
**psym
;
3152 struct objfile
*objfile
;
3153 struct minimal_symbol
*msymbol
;
3156 static enum minimal_symbol_type types
[]
3158 {mst_data
, mst_text
, mst_abs
, mst_unknown
};
3159 static enum minimal_symbol_type types2
[]
3161 {mst_bss
, mst_file_text
, mst_abs
, mst_unknown
};
3162 static enum minimal_symbol_type types3
[]
3164 {mst_file_data
, mst_solib_trampoline
, mst_abs
, mst_unknown
};
3165 static enum minimal_symbol_type types4
[]
3167 {mst_file_bss
, mst_text
, mst_abs
, mst_unknown
};
3168 enum minimal_symbol_type ourtype
;
3169 enum minimal_symbol_type ourtype2
;
3170 enum minimal_symbol_type ourtype3
;
3171 enum minimal_symbol_type ourtype4
;
3172 struct symbol_search
*sr
;
3173 struct symbol_search
*psr
;
3174 struct symbol_search
*tail
;
3175 struct cleanup
*old_chain
= NULL
;
3177 if (kind
< VARIABLES_DOMAIN
)
3178 error (_("must search on specific domain"));
3180 ourtype
= types
[(int) (kind
- VARIABLES_DOMAIN
)];
3181 ourtype2
= types2
[(int) (kind
- VARIABLES_DOMAIN
)];
3182 ourtype3
= types3
[(int) (kind
- VARIABLES_DOMAIN
)];
3183 ourtype4
= types4
[(int) (kind
- VARIABLES_DOMAIN
)];
3185 sr
= *matches
= NULL
;
3190 /* Make sure spacing is right for C++ operators.
3191 This is just a courtesy to make the matching less sensitive
3192 to how many spaces the user leaves between 'operator'
3193 and <TYPENAME> or <OPERATOR>. */
3195 char *opname
= operator_chars (regexp
, &opend
);
3198 int fix
= -1; /* -1 means ok; otherwise number of spaces needed. */
3199 if (isalpha (*opname
) || *opname
== '_' || *opname
== '$')
3201 /* There should 1 space between 'operator' and 'TYPENAME'. */
3202 if (opname
[-1] != ' ' || opname
[-2] == ' ')
3207 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
3208 if (opname
[-1] == ' ')
3211 /* If wrong number of spaces, fix it. */
3214 char *tmp
= (char *) alloca (8 + fix
+ strlen (opname
) + 1);
3215 sprintf (tmp
, "operator%.*s%s", fix
, " ", opname
);
3220 if (0 != (val
= re_comp (regexp
)))
3221 error (_("Invalid regexp (%s): %s"), val
, regexp
);
3224 /* Search through the partial symtabs *first* for all symbols
3225 matching the regexp. That way we don't have to reproduce all of
3226 the machinery below. */
3228 ALL_PSYMTABS (objfile
, ps
)
3230 struct partial_symbol
**bound
, **gbound
, **sbound
;
3236 gbound
= objfile
->global_psymbols
.list
+ ps
->globals_offset
+ ps
->n_global_syms
;
3237 sbound
= objfile
->static_psymbols
.list
+ ps
->statics_offset
+ ps
->n_static_syms
;
3240 /* Go through all of the symbols stored in a partial
3241 symtab in one loop. */
3242 psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
3247 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
3249 psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
3260 /* If it would match (logic taken from loop below)
3261 load the file and go on to the next one. We check the
3262 filename here, but that's a bit bogus: we don't know
3263 what file it really comes from until we have full
3264 symtabs. The symbol might be in a header file included by
3265 this psymtab. This only affects Insight. */
3266 if (file_matches (ps
->filename
, files
, nfiles
)
3268 || re_exec (SYMBOL_NATURAL_NAME (*psym
)) != 0)
3269 && ((kind
== VARIABLES_DOMAIN
&& SYMBOL_CLASS (*psym
) != LOC_TYPEDEF
3270 && SYMBOL_CLASS (*psym
) != LOC_UNRESOLVED
3271 && SYMBOL_CLASS (*psym
) != LOC_BLOCK
3272 && SYMBOL_CLASS (*psym
) != LOC_CONST
)
3273 || (kind
== FUNCTIONS_DOMAIN
&& SYMBOL_CLASS (*psym
) == LOC_BLOCK
)
3274 || (kind
== TYPES_DOMAIN
&& SYMBOL_CLASS (*psym
) == LOC_TYPEDEF
))))
3276 PSYMTAB_TO_SYMTAB (ps
);
3284 /* Here, we search through the minimal symbol tables for functions
3285 and variables that match, and force their symbols to be read.
3286 This is in particular necessary for demangled variable names,
3287 which are no longer put into the partial symbol tables.
3288 The symbol will then be found during the scan of symtabs below.
3290 For functions, find_pc_symtab should succeed if we have debug info
3291 for the function, for variables we have to call lookup_symbol
3292 to determine if the variable has debug info.
3293 If the lookup fails, set found_misc so that we will rescan to print
3294 any matching symbols without debug info.
3297 if (nfiles
== 0 && (kind
== VARIABLES_DOMAIN
|| kind
== FUNCTIONS_DOMAIN
))
3299 ALL_MSYMBOLS (objfile
, msymbol
)
3303 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
3304 MSYMBOL_TYPE (msymbol
) == ourtype2
||
3305 MSYMBOL_TYPE (msymbol
) == ourtype3
||
3306 MSYMBOL_TYPE (msymbol
) == ourtype4
)
3309 || re_exec (SYMBOL_NATURAL_NAME (msymbol
)) != 0)
3311 if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
)))
3313 /* FIXME: carlton/2003-02-04: Given that the
3314 semantics of lookup_symbol keeps on changing
3315 slightly, it would be a nice idea if we had a
3316 function lookup_symbol_minsym that found the
3317 symbol associated to a given minimal symbol (if
3319 if (kind
== FUNCTIONS_DOMAIN
3320 || lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol
),
3321 (struct block
*) NULL
,
3331 ALL_PRIMARY_SYMTABS (objfile
, s
)
3333 bv
= BLOCKVECTOR (s
);
3334 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
3336 struct symbol_search
*prevtail
= tail
;
3338 b
= BLOCKVECTOR_BLOCK (bv
, i
);
3339 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
3341 struct symtab
*real_symtab
= SYMBOL_SYMTAB (sym
);
3344 if (file_matches (real_symtab
->filename
, files
, nfiles
)
3346 || re_exec (SYMBOL_NATURAL_NAME (sym
)) != 0)
3347 && ((kind
== VARIABLES_DOMAIN
&& SYMBOL_CLASS (sym
) != LOC_TYPEDEF
3348 && SYMBOL_CLASS (sym
) != LOC_UNRESOLVED
3349 && SYMBOL_CLASS (sym
) != LOC_BLOCK
3350 && SYMBOL_CLASS (sym
) != LOC_CONST
)
3351 || (kind
== FUNCTIONS_DOMAIN
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
3352 || (kind
== TYPES_DOMAIN
&& SYMBOL_CLASS (sym
) == LOC_TYPEDEF
))))
3355 psr
= (struct symbol_search
*) xmalloc (sizeof (struct symbol_search
));
3357 psr
->symtab
= real_symtab
;
3359 psr
->msymbol
= NULL
;
3371 if (prevtail
== NULL
)
3373 struct symbol_search dummy
;
3376 tail
= sort_search_symbols (&dummy
, nfound
);
3379 old_chain
= make_cleanup_free_search_symbols (sr
);
3382 tail
= sort_search_symbols (prevtail
, nfound
);
3387 /* If there are no eyes, avoid all contact. I mean, if there are
3388 no debug symbols, then print directly from the msymbol_vector. */
3390 if (found_misc
|| kind
!= FUNCTIONS_DOMAIN
)
3392 ALL_MSYMBOLS (objfile
, msymbol
)
3396 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
3397 MSYMBOL_TYPE (msymbol
) == ourtype2
||
3398 MSYMBOL_TYPE (msymbol
) == ourtype3
||
3399 MSYMBOL_TYPE (msymbol
) == ourtype4
)
3402 || re_exec (SYMBOL_NATURAL_NAME (msymbol
)) != 0)
3404 /* Functions: Look up by address. */
3405 if (kind
!= FUNCTIONS_DOMAIN
||
3406 (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
))))
3408 /* Variables/Absolutes: Look up by name */
3409 if (lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol
),
3410 (struct block
*) NULL
, VAR_DOMAIN
, 0)
3414 psr
= (struct symbol_search
*) xmalloc (sizeof (struct symbol_search
));
3416 psr
->msymbol
= msymbol
;
3423 old_chain
= make_cleanup_free_search_symbols (sr
);
3437 discard_cleanups (old_chain
);
3440 /* Helper function for symtab_symbol_info, this function uses
3441 the data returned from search_symbols() to print information
3442 regarding the match to gdb_stdout.
3445 print_symbol_info (domain_enum kind
, struct symtab
*s
, struct symbol
*sym
,
3446 int block
, char *last
)
3448 if (last
== NULL
|| strcmp (last
, s
->filename
) != 0)
3450 fputs_filtered ("\nFile ", gdb_stdout
);
3451 fputs_filtered (s
->filename
, gdb_stdout
);
3452 fputs_filtered (":\n", gdb_stdout
);
3455 if (kind
!= TYPES_DOMAIN
&& block
== STATIC_BLOCK
)
3456 printf_filtered ("static ");
3458 /* Typedef that is not a C++ class */
3459 if (kind
== TYPES_DOMAIN
3460 && SYMBOL_DOMAIN (sym
) != STRUCT_DOMAIN
)
3461 typedef_print (SYMBOL_TYPE (sym
), sym
, gdb_stdout
);
3462 /* variable, func, or typedef-that-is-c++-class */
3463 else if (kind
< TYPES_DOMAIN
||
3464 (kind
== TYPES_DOMAIN
&&
3465 SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
))
3467 type_print (SYMBOL_TYPE (sym
),
3468 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
3469 ? "" : SYMBOL_PRINT_NAME (sym
)),
3472 printf_filtered (";\n");
3476 /* This help function for symtab_symbol_info() prints information
3477 for non-debugging symbols to gdb_stdout.
3480 print_msymbol_info (struct minimal_symbol
*msymbol
)
3482 struct gdbarch
*gdbarch
= get_objfile_arch (msymbol_objfile (msymbol
));
3485 if (gdbarch_addr_bit (gdbarch
) <= 32)
3486 tmp
= hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol
)
3487 & (CORE_ADDR
) 0xffffffff,
3490 tmp
= hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol
),
3492 printf_filtered ("%s %s\n",
3493 tmp
, SYMBOL_PRINT_NAME (msymbol
));
3496 /* This is the guts of the commands "info functions", "info types", and
3497 "info variables". It calls search_symbols to find all matches and then
3498 print_[m]symbol_info to print out some useful information about the
3502 symtab_symbol_info (char *regexp
, domain_enum kind
, int from_tty
)
3504 static char *classnames
[]
3506 {"variable", "function", "type", "method"};
3507 struct symbol_search
*symbols
;
3508 struct symbol_search
*p
;
3509 struct cleanup
*old_chain
;
3510 char *last_filename
= NULL
;
3513 /* must make sure that if we're interrupted, symbols gets freed */
3514 search_symbols (regexp
, kind
, 0, (char **) NULL
, &symbols
);
3515 old_chain
= make_cleanup_free_search_symbols (symbols
);
3517 printf_filtered (regexp
3518 ? "All %ss matching regular expression \"%s\":\n"
3519 : "All defined %ss:\n",
3520 classnames
[(int) (kind
- VARIABLES_DOMAIN
)], regexp
);
3522 for (p
= symbols
; p
!= NULL
; p
= p
->next
)
3526 if (p
->msymbol
!= NULL
)
3530 printf_filtered ("\nNon-debugging symbols:\n");
3533 print_msymbol_info (p
->msymbol
);
3537 print_symbol_info (kind
,
3542 last_filename
= p
->symtab
->filename
;
3546 do_cleanups (old_chain
);
3550 variables_info (char *regexp
, int from_tty
)
3552 symtab_symbol_info (regexp
, VARIABLES_DOMAIN
, from_tty
);
3556 functions_info (char *regexp
, int from_tty
)
3558 symtab_symbol_info (regexp
, FUNCTIONS_DOMAIN
, from_tty
);
3563 types_info (char *regexp
, int from_tty
)
3565 symtab_symbol_info (regexp
, TYPES_DOMAIN
, from_tty
);
3568 /* Breakpoint all functions matching regular expression. */
3571 rbreak_command_wrapper (char *regexp
, int from_tty
)
3573 rbreak_command (regexp
, from_tty
);
3577 rbreak_command (char *regexp
, int from_tty
)
3579 struct symbol_search
*ss
;
3580 struct symbol_search
*p
;
3581 struct cleanup
*old_chain
;
3583 search_symbols (regexp
, FUNCTIONS_DOMAIN
, 0, (char **) NULL
, &ss
);
3584 old_chain
= make_cleanup_free_search_symbols (ss
);
3586 for (p
= ss
; p
!= NULL
; p
= p
->next
)
3588 if (p
->msymbol
== NULL
)
3590 char *string
= alloca (strlen (p
->symtab
->filename
)
3591 + strlen (SYMBOL_LINKAGE_NAME (p
->symbol
))
3593 strcpy (string
, p
->symtab
->filename
);
3594 strcat (string
, ":'");
3595 strcat (string
, SYMBOL_LINKAGE_NAME (p
->symbol
));
3596 strcat (string
, "'");
3597 break_command (string
, from_tty
);
3598 print_symbol_info (FUNCTIONS_DOMAIN
,
3602 p
->symtab
->filename
);
3606 char *string
= alloca (strlen (SYMBOL_LINKAGE_NAME (p
->msymbol
))
3608 strcpy (string
, "'");
3609 strcat (string
, SYMBOL_LINKAGE_NAME (p
->msymbol
));
3610 strcat (string
, "'");
3612 break_command (string
, from_tty
);
3613 printf_filtered ("<function, no debug info> %s;\n",
3614 SYMBOL_PRINT_NAME (p
->msymbol
));
3618 do_cleanups (old_chain
);
3622 /* Helper routine for make_symbol_completion_list. */
3624 static int return_val_size
;
3625 static int return_val_index
;
3626 static char **return_val
;
3628 #define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
3629 completion_list_add_name \
3630 (SYMBOL_NATURAL_NAME (symbol), (sym_text), (len), (text), (word))
3632 /* Test to see if the symbol specified by SYMNAME (which is already
3633 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
3634 characters. If so, add it to the current completion list. */
3637 completion_list_add_name (char *symname
, char *sym_text
, int sym_text_len
,
3638 char *text
, char *word
)
3643 /* clip symbols that cannot match */
3645 if (strncmp (symname
, sym_text
, sym_text_len
) != 0)
3650 /* We have a match for a completion, so add SYMNAME to the current list
3651 of matches. Note that the name is moved to freshly malloc'd space. */
3655 if (word
== sym_text
)
3657 new = xmalloc (strlen (symname
) + 5);
3658 strcpy (new, symname
);
3660 else if (word
> sym_text
)
3662 /* Return some portion of symname. */
3663 new = xmalloc (strlen (symname
) + 5);
3664 strcpy (new, symname
+ (word
- sym_text
));
3668 /* Return some of SYM_TEXT plus symname. */
3669 new = xmalloc (strlen (symname
) + (sym_text
- word
) + 5);
3670 strncpy (new, word
, sym_text
- word
);
3671 new[sym_text
- word
] = '\0';
3672 strcat (new, symname
);
3675 if (return_val_index
+ 3 > return_val_size
)
3677 newsize
= (return_val_size
*= 2) * sizeof (char *);
3678 return_val
= (char **) xrealloc ((char *) return_val
, newsize
);
3680 return_val
[return_val_index
++] = new;
3681 return_val
[return_val_index
] = NULL
;
3685 /* ObjC: In case we are completing on a selector, look as the msymbol
3686 again and feed all the selectors into the mill. */
3689 completion_list_objc_symbol (struct minimal_symbol
*msymbol
, char *sym_text
,
3690 int sym_text_len
, char *text
, char *word
)
3692 static char *tmp
= NULL
;
3693 static unsigned int tmplen
= 0;
3695 char *method
, *category
, *selector
;
3698 method
= SYMBOL_NATURAL_NAME (msymbol
);
3700 /* Is it a method? */
3701 if ((method
[0] != '-') && (method
[0] != '+'))
3704 if (sym_text
[0] == '[')
3705 /* Complete on shortened method method. */
3706 completion_list_add_name (method
+ 1, sym_text
, sym_text_len
, text
, word
);
3708 while ((strlen (method
) + 1) >= tmplen
)
3714 tmp
= xrealloc (tmp
, tmplen
);
3716 selector
= strchr (method
, ' ');
3717 if (selector
!= NULL
)
3720 category
= strchr (method
, '(');
3722 if ((category
!= NULL
) && (selector
!= NULL
))
3724 memcpy (tmp
, method
, (category
- method
));
3725 tmp
[category
- method
] = ' ';
3726 memcpy (tmp
+ (category
- method
) + 1, selector
, strlen (selector
) + 1);
3727 completion_list_add_name (tmp
, sym_text
, sym_text_len
, text
, word
);
3728 if (sym_text
[0] == '[')
3729 completion_list_add_name (tmp
+ 1, sym_text
, sym_text_len
, text
, word
);
3732 if (selector
!= NULL
)
3734 /* Complete on selector only. */
3735 strcpy (tmp
, selector
);
3736 tmp2
= strchr (tmp
, ']');
3740 completion_list_add_name (tmp
, sym_text
, sym_text_len
, text
, word
);
3744 /* Break the non-quoted text based on the characters which are in
3745 symbols. FIXME: This should probably be language-specific. */
3748 language_search_unquoted_string (char *text
, char *p
)
3750 for (; p
> text
; --p
)
3752 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
3756 if ((current_language
->la_language
== language_objc
))
3758 if (p
[-1] == ':') /* might be part of a method name */
3760 else if (p
[-1] == '[' && (p
[-2] == '-' || p
[-2] == '+'))
3761 p
-= 2; /* beginning of a method name */
3762 else if (p
[-1] == ' ' || p
[-1] == '(' || p
[-1] == ')')
3763 { /* might be part of a method name */
3766 /* Seeing a ' ' or a '(' is not conclusive evidence
3767 that we are in the middle of a method name. However,
3768 finding "-[" or "+[" should be pretty un-ambiguous.
3769 Unfortunately we have to find it now to decide. */
3772 if (isalnum (t
[-1]) || t
[-1] == '_' ||
3773 t
[-1] == ' ' || t
[-1] == ':' ||
3774 t
[-1] == '(' || t
[-1] == ')')
3779 if (t
[-1] == '[' && (t
[-2] == '-' || t
[-2] == '+'))
3780 p
= t
- 2; /* method name detected */
3781 /* else we leave with p unchanged */
3791 completion_list_add_fields (struct symbol
*sym
, char *sym_text
,
3792 int sym_text_len
, char *text
, char *word
)
3794 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
3796 struct type
*t
= SYMBOL_TYPE (sym
);
3797 enum type_code c
= TYPE_CODE (t
);
3800 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
3801 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
3802 if (TYPE_FIELD_NAME (t
, j
))
3803 completion_list_add_name (TYPE_FIELD_NAME (t
, j
),
3804 sym_text
, sym_text_len
, text
, word
);
3808 /* Type of the user_data argument passed to add_macro_name. The
3809 contents are simply whatever is needed by
3810 completion_list_add_name. */
3811 struct add_macro_name_data
3819 /* A callback used with macro_for_each and macro_for_each_in_scope.
3820 This adds a macro's name to the current completion list. */
3822 add_macro_name (const char *name
, const struct macro_definition
*ignore
,
3825 struct add_macro_name_data
*datum
= (struct add_macro_name_data
*) user_data
;
3826 completion_list_add_name ((char *) name
,
3827 datum
->sym_text
, datum
->sym_text_len
,
3828 datum
->text
, datum
->word
);
3832 default_make_symbol_completion_list (char *text
, char *word
)
3834 /* Problem: All of the symbols have to be copied because readline
3835 frees them. I'm not going to worry about this; hopefully there
3836 won't be that many. */
3840 struct partial_symtab
*ps
;
3841 struct minimal_symbol
*msymbol
;
3842 struct objfile
*objfile
;
3844 const struct block
*surrounding_static_block
, *surrounding_global_block
;
3845 struct dict_iterator iter
;
3846 struct partial_symbol
**psym
;
3847 /* The symbol we are completing on. Points in same buffer as text. */
3849 /* Length of sym_text. */
3852 /* Now look for the symbol we are supposed to complete on. */
3856 char *quote_pos
= NULL
;
3858 /* First see if this is a quoted string. */
3860 for (p
= text
; *p
!= '\0'; ++p
)
3862 if (quote_found
!= '\0')
3864 if (*p
== quote_found
)
3865 /* Found close quote. */
3867 else if (*p
== '\\' && p
[1] == quote_found
)
3868 /* A backslash followed by the quote character
3869 doesn't end the string. */
3872 else if (*p
== '\'' || *p
== '"')
3878 if (quote_found
== '\'')
3879 /* A string within single quotes can be a symbol, so complete on it. */
3880 sym_text
= quote_pos
+ 1;
3881 else if (quote_found
== '"')
3882 /* A double-quoted string is never a symbol, nor does it make sense
3883 to complete it any other way. */
3885 return_val
= (char **) xmalloc (sizeof (char *));
3886 return_val
[0] = NULL
;
3891 /* It is not a quoted string. Break it based on the characters
3892 which are in symbols. */
3895 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0'
3905 sym_text_len
= strlen (sym_text
);
3907 return_val_size
= 100;
3908 return_val_index
= 0;
3909 return_val
= (char **) xmalloc ((return_val_size
+ 1) * sizeof (char *));
3910 return_val
[0] = NULL
;
3912 /* Look through the partial symtabs for all symbols which begin
3913 by matching SYM_TEXT. Add each one that you find to the list. */
3915 ALL_PSYMTABS (objfile
, ps
)
3917 /* If the psymtab's been read in we'll get it when we search
3918 through the blockvector. */
3922 for (psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
3923 psym
< (objfile
->global_psymbols
.list
+ ps
->globals_offset
3924 + ps
->n_global_syms
);
3927 /* If interrupted, then quit. */
3929 COMPLETION_LIST_ADD_SYMBOL (*psym
, sym_text
, sym_text_len
, text
, word
);
3932 for (psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
3933 psym
< (objfile
->static_psymbols
.list
+ ps
->statics_offset
3934 + ps
->n_static_syms
);
3938 COMPLETION_LIST_ADD_SYMBOL (*psym
, sym_text
, sym_text_len
, text
, word
);
3942 /* At this point scan through the misc symbol vectors and add each
3943 symbol you find to the list. Eventually we want to ignore
3944 anything that isn't a text symbol (everything else will be
3945 handled by the psymtab code above). */
3947 ALL_MSYMBOLS (objfile
, msymbol
)
3950 COMPLETION_LIST_ADD_SYMBOL (msymbol
, sym_text
, sym_text_len
, text
, word
);
3952 completion_list_objc_symbol (msymbol
, sym_text
, sym_text_len
, text
, word
);
3955 /* Search upwards from currently selected frame (so that we can
3956 complete on local vars). Also catch fields of types defined in
3957 this places which match our text string. Only complete on types
3958 visible from current context. */
3960 b
= get_selected_block (0);
3961 surrounding_static_block
= block_static_block (b
);
3962 surrounding_global_block
= block_global_block (b
);
3963 if (surrounding_static_block
!= NULL
)
3964 while (b
!= surrounding_static_block
)
3968 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
3970 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
,
3972 completion_list_add_fields (sym
, sym_text
, sym_text_len
, text
,
3976 /* Stop when we encounter an enclosing function. Do not stop for
3977 non-inlined functions - the locals of the enclosing function
3978 are in scope for a nested function. */
3979 if (BLOCK_FUNCTION (b
) != NULL
&& block_inlined_p (b
))
3981 b
= BLOCK_SUPERBLOCK (b
);
3984 /* Add fields from the file's types; symbols will be added below. */
3986 if (surrounding_static_block
!= NULL
)
3987 ALL_BLOCK_SYMBOLS (surrounding_static_block
, iter
, sym
)
3988 completion_list_add_fields (sym
, sym_text
, sym_text_len
, text
, word
);
3990 if (surrounding_global_block
!= NULL
)
3991 ALL_BLOCK_SYMBOLS (surrounding_global_block
, iter
, sym
)
3992 completion_list_add_fields (sym
, sym_text
, sym_text_len
, text
, word
);
3994 /* Go through the symtabs and check the externs and statics for
3995 symbols which match. */
3997 ALL_PRIMARY_SYMTABS (objfile
, s
)
4000 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
4001 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
4003 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
4007 ALL_PRIMARY_SYMTABS (objfile
, s
)
4010 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
4011 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
4013 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
4017 if (current_language
->la_macro_expansion
== macro_expansion_c
)
4019 struct macro_scope
*scope
;
4020 struct add_macro_name_data datum
;
4022 datum
.sym_text
= sym_text
;
4023 datum
.sym_text_len
= sym_text_len
;
4027 /* Add any macros visible in the default scope. Note that this
4028 may yield the occasional wrong result, because an expression
4029 might be evaluated in a scope other than the default. For
4030 example, if the user types "break file:line if <TAB>", the
4031 resulting expression will be evaluated at "file:line" -- but
4032 at there does not seem to be a way to detect this at
4034 scope
= default_macro_scope ();
4037 macro_for_each_in_scope (scope
->file
, scope
->line
,
4038 add_macro_name
, &datum
);
4042 /* User-defined macros are always visible. */
4043 macro_for_each (macro_user_macros
, add_macro_name
, &datum
);
4046 return (return_val
);
4049 /* Return a NULL terminated array of all symbols (regardless of class)
4050 which begin by matching TEXT. If the answer is no symbols, then
4051 the return value is an array which contains only a NULL pointer. */
4054 make_symbol_completion_list (char *text
, char *word
)
4056 return current_language
->la_make_symbol_completion_list (text
, word
);
4059 /* Like make_symbol_completion_list, but suitable for use as a
4060 completion function. */
4063 make_symbol_completion_list_fn (struct cmd_list_element
*ignore
,
4064 char *text
, char *word
)
4066 return make_symbol_completion_list (text
, word
);
4069 /* Like make_symbol_completion_list, but returns a list of symbols
4070 defined in a source file FILE. */
4073 make_file_symbol_completion_list (char *text
, char *word
, char *srcfile
)
4078 struct dict_iterator iter
;
4079 /* The symbol we are completing on. Points in same buffer as text. */
4081 /* Length of sym_text. */
4084 /* Now look for the symbol we are supposed to complete on.
4085 FIXME: This should be language-specific. */
4089 char *quote_pos
= NULL
;
4091 /* First see if this is a quoted string. */
4093 for (p
= text
; *p
!= '\0'; ++p
)
4095 if (quote_found
!= '\0')
4097 if (*p
== quote_found
)
4098 /* Found close quote. */
4100 else if (*p
== '\\' && p
[1] == quote_found
)
4101 /* A backslash followed by the quote character
4102 doesn't end the string. */
4105 else if (*p
== '\'' || *p
== '"')
4111 if (quote_found
== '\'')
4112 /* A string within single quotes can be a symbol, so complete on it. */
4113 sym_text
= quote_pos
+ 1;
4114 else if (quote_found
== '"')
4115 /* A double-quoted string is never a symbol, nor does it make sense
4116 to complete it any other way. */
4118 return_val
= (char **) xmalloc (sizeof (char *));
4119 return_val
[0] = NULL
;
4124 /* Not a quoted string. */
4125 sym_text
= language_search_unquoted_string (text
, p
);
4129 sym_text_len
= strlen (sym_text
);
4131 return_val_size
= 10;
4132 return_val_index
= 0;
4133 return_val
= (char **) xmalloc ((return_val_size
+ 1) * sizeof (char *));
4134 return_val
[0] = NULL
;
4136 /* Find the symtab for SRCFILE (this loads it if it was not yet read
4138 s
= lookup_symtab (srcfile
);
4141 /* Maybe they typed the file with leading directories, while the
4142 symbol tables record only its basename. */
4143 const char *tail
= lbasename (srcfile
);
4146 s
= lookup_symtab (tail
);
4149 /* If we have no symtab for that file, return an empty list. */
4151 return (return_val
);
4153 /* Go through this symtab and check the externs and statics for
4154 symbols which match. */
4156 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
4157 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
4159 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
4162 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
4163 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
4165 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
4168 return (return_val
);
4171 /* A helper function for make_source_files_completion_list. It adds
4172 another file name to a list of possible completions, growing the
4173 list as necessary. */
4176 add_filename_to_list (const char *fname
, char *text
, char *word
,
4177 char ***list
, int *list_used
, int *list_alloced
)
4180 size_t fnlen
= strlen (fname
);
4182 if (*list_used
+ 1 >= *list_alloced
)
4185 *list
= (char **) xrealloc ((char *) *list
,
4186 *list_alloced
* sizeof (char *));
4191 /* Return exactly fname. */
4192 new = xmalloc (fnlen
+ 5);
4193 strcpy (new, fname
);
4195 else if (word
> text
)
4197 /* Return some portion of fname. */
4198 new = xmalloc (fnlen
+ 5);
4199 strcpy (new, fname
+ (word
- text
));
4203 /* Return some of TEXT plus fname. */
4204 new = xmalloc (fnlen
+ (text
- word
) + 5);
4205 strncpy (new, word
, text
- word
);
4206 new[text
- word
] = '\0';
4207 strcat (new, fname
);
4209 (*list
)[*list_used
] = new;
4210 (*list
)[++*list_used
] = NULL
;
4214 not_interesting_fname (const char *fname
)
4216 static const char *illegal_aliens
[] = {
4217 "_globals_", /* inserted by coff_symtab_read */
4222 for (i
= 0; illegal_aliens
[i
]; i
++)
4224 if (strcmp (fname
, illegal_aliens
[i
]) == 0)
4230 /* Return a NULL terminated array of all source files whose names
4231 begin with matching TEXT. The file names are looked up in the
4232 symbol tables of this program. If the answer is no matchess, then
4233 the return value is an array which contains only a NULL pointer. */
4236 make_source_files_completion_list (char *text
, char *word
)
4239 struct partial_symtab
*ps
;
4240 struct objfile
*objfile
;
4242 int list_alloced
= 1;
4244 size_t text_len
= strlen (text
);
4245 char **list
= (char **) xmalloc (list_alloced
* sizeof (char *));
4246 const char *base_name
;
4250 if (!have_full_symbols () && !have_partial_symbols ())
4253 ALL_SYMTABS (objfile
, s
)
4255 if (not_interesting_fname (s
->filename
))
4257 if (!filename_seen (s
->filename
, 1, &first
)
4258 #if HAVE_DOS_BASED_FILE_SYSTEM
4259 && strncasecmp (s
->filename
, text
, text_len
) == 0
4261 && strncmp (s
->filename
, text
, text_len
) == 0
4265 /* This file matches for a completion; add it to the current
4267 add_filename_to_list (s
->filename
, text
, word
,
4268 &list
, &list_used
, &list_alloced
);
4272 /* NOTE: We allow the user to type a base name when the
4273 debug info records leading directories, but not the other
4274 way around. This is what subroutines of breakpoint
4275 command do when they parse file names. */
4276 base_name
= lbasename (s
->filename
);
4277 if (base_name
!= s
->filename
4278 && !filename_seen (base_name
, 1, &first
)
4279 #if HAVE_DOS_BASED_FILE_SYSTEM
4280 && strncasecmp (base_name
, text
, text_len
) == 0
4282 && strncmp (base_name
, text
, text_len
) == 0
4285 add_filename_to_list (base_name
, text
, word
,
4286 &list
, &list_used
, &list_alloced
);
4290 ALL_PSYMTABS (objfile
, ps
)
4292 if (not_interesting_fname (ps
->filename
))
4296 if (!filename_seen (ps
->filename
, 1, &first
)
4297 #if HAVE_DOS_BASED_FILE_SYSTEM
4298 && strncasecmp (ps
->filename
, text
, text_len
) == 0
4300 && strncmp (ps
->filename
, text
, text_len
) == 0
4304 /* This file matches for a completion; add it to the
4305 current list of matches. */
4306 add_filename_to_list (ps
->filename
, text
, word
,
4307 &list
, &list_used
, &list_alloced
);
4312 base_name
= lbasename (ps
->filename
);
4313 if (base_name
!= ps
->filename
4314 && !filename_seen (base_name
, 1, &first
)
4315 #if HAVE_DOS_BASED_FILE_SYSTEM
4316 && strncasecmp (base_name
, text
, text_len
) == 0
4318 && strncmp (base_name
, text
, text_len
) == 0
4321 add_filename_to_list (base_name
, text
, word
,
4322 &list
, &list_used
, &list_alloced
);
4330 /* Determine if PC is in the prologue of a function. The prologue is the area
4331 between the first instruction of a function, and the first executable line.
4332 Returns 1 if PC *might* be in prologue, 0 if definately *not* in prologue.
4334 If non-zero, func_start is where we think the prologue starts, possibly
4335 by previous examination of symbol table information.
4339 in_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
, CORE_ADDR func_start
)
4341 struct symtab_and_line sal
;
4342 CORE_ADDR func_addr
, func_end
;
4344 /* We have several sources of information we can consult to figure
4346 - Compilers usually emit line number info that marks the prologue
4347 as its own "source line". So the ending address of that "line"
4348 is the end of the prologue. If available, this is the most
4350 - The minimal symbols and partial symbols, which can usually tell
4351 us the starting and ending addresses of a function.
4352 - If we know the function's start address, we can call the
4353 architecture-defined gdbarch_skip_prologue function to analyze the
4354 instruction stream and guess where the prologue ends.
4355 - Our `func_start' argument; if non-zero, this is the caller's
4356 best guess as to the function's entry point. At the time of
4357 this writing, handle_inferior_event doesn't get this right, so
4358 it should be our last resort. */
4360 /* Consult the partial symbol table, to find which function
4362 if (! find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
4364 CORE_ADDR prologue_end
;
4366 /* We don't even have minsym information, so fall back to using
4367 func_start, if given. */
4369 return 1; /* We *might* be in a prologue. */
4371 prologue_end
= gdbarch_skip_prologue (gdbarch
, func_start
);
4373 return func_start
<= pc
&& pc
< prologue_end
;
4376 /* If we have line number information for the function, that's
4377 usually pretty reliable. */
4378 sal
= find_pc_line (func_addr
, 0);
4380 /* Now sal describes the source line at the function's entry point,
4381 which (by convention) is the prologue. The end of that "line",
4382 sal.end, is the end of the prologue.
4384 Note that, for functions whose source code is all on a single
4385 line, the line number information doesn't always end up this way.
4386 So we must verify that our purported end-of-prologue address is
4387 *within* the function, not at its start or end. */
4389 || sal
.end
<= func_addr
4390 || func_end
<= sal
.end
)
4392 /* We don't have any good line number info, so use the minsym
4393 information, together with the architecture-specific prologue
4395 CORE_ADDR prologue_end
= gdbarch_skip_prologue (gdbarch
, func_addr
);
4397 return func_addr
<= pc
&& pc
< prologue_end
;
4400 /* We have line number info, and it looks good. */
4401 return func_addr
<= pc
&& pc
< sal
.end
;
4404 /* Given PC at the function's start address, attempt to find the
4405 prologue end using SAL information. Return zero if the skip fails.
4407 A non-optimized prologue traditionally has one SAL for the function
4408 and a second for the function body. A single line function has
4409 them both pointing at the same line.
4411 An optimized prologue is similar but the prologue may contain
4412 instructions (SALs) from the instruction body. Need to skip those
4413 while not getting into the function body.
4415 The functions end point and an increasing SAL line are used as
4416 indicators of the prologue's endpoint.
4418 This code is based on the function refine_prologue_limit (versions
4419 found in both ia64 and ppc). */
4422 skip_prologue_using_sal (struct gdbarch
*gdbarch
, CORE_ADDR func_addr
)
4424 struct symtab_and_line prologue_sal
;
4429 /* Get an initial range for the function. */
4430 find_pc_partial_function (func_addr
, NULL
, &start_pc
, &end_pc
);
4431 start_pc
+= gdbarch_deprecated_function_start_offset (gdbarch
);
4433 prologue_sal
= find_pc_line (start_pc
, 0);
4434 if (prologue_sal
.line
!= 0)
4436 /* For langauges other than assembly, treat two consecutive line
4437 entries at the same address as a zero-instruction prologue.
4438 The GNU assembler emits separate line notes for each instruction
4439 in a multi-instruction macro, but compilers generally will not
4441 if (prologue_sal
.symtab
->language
!= language_asm
)
4443 struct linetable
*linetable
= LINETABLE (prologue_sal
.symtab
);
4447 /* Skip any earlier lines, and any end-of-sequence marker
4448 from a previous function. */
4449 while (linetable
->item
[idx
].pc
!= prologue_sal
.pc
4450 || linetable
->item
[idx
].line
== 0)
4453 if (idx
+1 < linetable
->nitems
4454 && linetable
->item
[idx
+1].line
!= 0
4455 && linetable
->item
[idx
+1].pc
== start_pc
)
4459 /* If there is only one sal that covers the entire function,
4460 then it is probably a single line function, like
4462 if (prologue_sal
.end
>= end_pc
)
4465 while (prologue_sal
.end
< end_pc
)
4467 struct symtab_and_line sal
;
4469 sal
= find_pc_line (prologue_sal
.end
, 0);
4472 /* Assume that a consecutive SAL for the same (or larger)
4473 line mark the prologue -> body transition. */
4474 if (sal
.line
>= prologue_sal
.line
)
4477 /* The line number is smaller. Check that it's from the
4478 same function, not something inlined. If it's inlined,
4479 then there is no point comparing the line numbers. */
4480 bl
= block_for_pc (prologue_sal
.end
);
4483 if (block_inlined_p (bl
))
4485 if (BLOCK_FUNCTION (bl
))
4490 bl
= BLOCK_SUPERBLOCK (bl
);
4495 /* The case in which compiler's optimizer/scheduler has
4496 moved instructions into the prologue. We look ahead in
4497 the function looking for address ranges whose
4498 corresponding line number is less the first one that we
4499 found for the function. This is more conservative then
4500 refine_prologue_limit which scans a large number of SALs
4501 looking for any in the prologue */
4506 if (prologue_sal
.end
< end_pc
)
4507 /* Return the end of this line, or zero if we could not find a
4509 return prologue_sal
.end
;
4511 /* Don't return END_PC, which is past the end of the function. */
4512 return prologue_sal
.pc
;
4515 struct symtabs_and_lines
4516 decode_line_spec (char *string
, int funfirstline
)
4518 struct symtabs_and_lines sals
;
4519 struct symtab_and_line cursal
;
4522 error (_("Empty line specification."));
4524 /* We use whatever is set as the current source line. We do not try
4525 and get a default or it will recursively call us! */
4526 cursal
= get_current_source_symtab_and_line ();
4528 sals
= decode_line_1 (&string
, funfirstline
,
4529 cursal
.symtab
, cursal
.line
,
4530 (char ***) NULL
, NULL
);
4533 error (_("Junk at end of line specification: %s"), string
);
4538 static char *name_of_main
;
4541 set_main_name (const char *name
)
4543 if (name_of_main
!= NULL
)
4545 xfree (name_of_main
);
4546 name_of_main
= NULL
;
4550 name_of_main
= xstrdup (name
);
4554 /* Deduce the name of the main procedure, and set NAME_OF_MAIN
4558 find_main_name (void)
4560 const char *new_main_name
;
4562 /* Try to see if the main procedure is in Ada. */
4563 /* FIXME: brobecker/2005-03-07: Another way of doing this would
4564 be to add a new method in the language vector, and call this
4565 method for each language until one of them returns a non-empty
4566 name. This would allow us to remove this hard-coded call to
4567 an Ada function. It is not clear that this is a better approach
4568 at this point, because all methods need to be written in a way
4569 such that false positives never be returned. For instance, it is
4570 important that a method does not return a wrong name for the main
4571 procedure if the main procedure is actually written in a different
4572 language. It is easy to guaranty this with Ada, since we use a
4573 special symbol generated only when the main in Ada to find the name
4574 of the main procedure. It is difficult however to see how this can
4575 be guarantied for languages such as C, for instance. This suggests
4576 that order of call for these methods becomes important, which means
4577 a more complicated approach. */
4578 new_main_name
= ada_main_name ();
4579 if (new_main_name
!= NULL
)
4581 set_main_name (new_main_name
);
4585 new_main_name
= pascal_main_name ();
4586 if (new_main_name
!= NULL
)
4588 set_main_name (new_main_name
);
4592 /* The languages above didn't identify the name of the main procedure.
4593 Fallback to "main". */
4594 set_main_name ("main");
4600 if (name_of_main
== NULL
)
4603 return name_of_main
;
4606 /* Handle ``executable_changed'' events for the symtab module. */
4609 symtab_observer_executable_changed (void)
4611 /* NAME_OF_MAIN may no longer be the same, so reset it for now. */
4612 set_main_name (NULL
);
4615 /* Helper to expand_line_sal below. Appends new sal to SAL,
4616 initializing it from SYMTAB, LINENO and PC. */
4618 append_expanded_sal (struct symtabs_and_lines
*sal
,
4619 struct program_space
*pspace
,
4620 struct symtab
*symtab
,
4621 int lineno
, CORE_ADDR pc
)
4623 sal
->sals
= xrealloc (sal
->sals
,
4624 sizeof (sal
->sals
[0])
4625 * (sal
->nelts
+ 1));
4626 init_sal (sal
->sals
+ sal
->nelts
);
4627 sal
->sals
[sal
->nelts
].pspace
= pspace
;
4628 sal
->sals
[sal
->nelts
].symtab
= symtab
;
4629 sal
->sals
[sal
->nelts
].section
= NULL
;
4630 sal
->sals
[sal
->nelts
].end
= 0;
4631 sal
->sals
[sal
->nelts
].line
= lineno
;
4632 sal
->sals
[sal
->nelts
].pc
= pc
;
4636 /* Helper to expand_line_sal below. Search in the symtabs for any
4637 linetable entry that exactly matches FULLNAME and LINENO and append
4638 them to RET. If FULLNAME is NULL or if a symtab has no full name,
4639 use FILENAME and LINENO instead. If there is at least one match,
4640 return 1; otherwise, return 0, and return the best choice in BEST_ITEM
4644 append_exact_match_to_sals (char *filename
, char *fullname
, int lineno
,
4645 struct symtabs_and_lines
*ret
,
4646 struct linetable_entry
**best_item
,
4647 struct symtab
**best_symtab
)
4649 struct program_space
*pspace
;
4650 struct objfile
*objfile
;
4651 struct symtab
*symtab
;
4657 ALL_PSPACES (pspace
)
4658 ALL_PSPACE_SYMTABS (pspace
, objfile
, symtab
)
4660 if (FILENAME_CMP (filename
, symtab
->filename
) == 0)
4662 struct linetable
*l
;
4664 if (fullname
!= NULL
4665 && symtab_to_fullname (symtab
) != NULL
4666 && FILENAME_CMP (fullname
, symtab
->fullname
) != 0)
4668 l
= LINETABLE (symtab
);
4673 for (j
= 0; j
< len
; j
++)
4675 struct linetable_entry
*item
= &(l
->item
[j
]);
4677 if (item
->line
== lineno
)
4680 append_expanded_sal (ret
, objfile
->pspace
,
4681 symtab
, lineno
, item
->pc
);
4683 else if (!exact
&& item
->line
> lineno
4684 && (*best_item
== NULL
4685 || item
->line
< (*best_item
)->line
))
4688 *best_symtab
= symtab
;
4696 /* Compute a set of all sals in all program spaces that correspond to
4697 same file and line as SAL and return those. If there are several
4698 sals that belong to the same block, only one sal for the block is
4699 included in results. */
4701 struct symtabs_and_lines
4702 expand_line_sal (struct symtab_and_line sal
)
4704 struct symtabs_and_lines ret
, this_line
;
4706 struct objfile
*objfile
;
4707 struct partial_symtab
*psymtab
;
4708 struct symtab
*symtab
;
4711 struct block
**blocks
= NULL
;
4713 struct cleanup
*old_chain
;
4718 /* Only expand sals that represent file.c:line. */
4719 if (sal
.symtab
== NULL
|| sal
.line
== 0 || sal
.pc
!= 0)
4721 ret
.sals
= xmalloc (sizeof (struct symtab_and_line
));
4728 struct program_space
*pspace
;
4729 struct linetable_entry
*best_item
= 0;
4730 struct symtab
*best_symtab
= 0;
4732 char *match_filename
;
4735 match_filename
= sal
.symtab
->filename
;
4737 /* We need to find all symtabs for a file which name
4738 is described by sal. We cannot just directly
4739 iterate over symtabs, since a symtab might not be
4740 yet created. We also cannot iterate over psymtabs,
4741 calling PSYMTAB_TO_SYMTAB and working on that symtab,
4742 since PSYMTAB_TO_SYMTAB will return NULL for psymtab
4743 corresponding to an included file. Therefore, we do
4744 first pass over psymtabs, reading in those with
4745 the right name. Then, we iterate over symtabs, knowing
4746 that all symtabs we're interested in are loaded. */
4748 old_chain
= save_current_program_space ();
4749 ALL_PSPACES (pspace
)
4750 ALL_PSPACE_PSYMTABS (pspace
, objfile
, psymtab
)
4752 if (FILENAME_CMP (match_filename
, psymtab
->filename
) == 0)
4754 set_current_program_space (pspace
);
4756 PSYMTAB_TO_SYMTAB (psymtab
);
4759 do_cleanups (old_chain
);
4761 /* Now search the symtab for exact matches and append them. If
4762 none is found, append the best_item and all its exact
4764 symtab_to_fullname (sal
.symtab
);
4765 exact
= append_exact_match_to_sals (sal
.symtab
->filename
,
4766 sal
.symtab
->fullname
, lineno
,
4767 &ret
, &best_item
, &best_symtab
);
4768 if (!exact
&& best_item
)
4769 append_exact_match_to_sals (best_symtab
->filename
,
4770 best_symtab
->fullname
, best_item
->line
,
4771 &ret
, &best_item
, &best_symtab
);
4774 /* For optimized code, compiler can scatter one source line accross
4775 disjoint ranges of PC values, even when no duplicate functions
4776 or inline functions are involved. For example, 'for (;;)' inside
4777 non-template non-inline non-ctor-or-dtor function can result
4778 in two PC ranges. In this case, we don't want to set breakpoint
4779 on first PC of each range. To filter such cases, we use containing
4780 blocks -- for each PC found above we see if there are other PCs
4781 that are in the same block. If yes, the other PCs are filtered out. */
4783 old_chain
= save_current_program_space ();
4784 filter
= alloca (ret
.nelts
* sizeof (int));
4785 blocks
= alloca (ret
.nelts
* sizeof (struct block
*));
4786 for (i
= 0; i
< ret
.nelts
; ++i
)
4788 struct blockvector
*bl
;
4791 set_current_program_space (ret
.sals
[i
].pspace
);
4794 blocks
[i
] = block_for_pc_sect (ret
.sals
[i
].pc
, ret
.sals
[i
].section
);
4797 do_cleanups (old_chain
);
4799 for (i
= 0; i
< ret
.nelts
; ++i
)
4800 if (blocks
[i
] != NULL
)
4801 for (j
= i
+1; j
< ret
.nelts
; ++j
)
4802 if (blocks
[j
] == blocks
[i
])
4810 struct symtab_and_line
*final
=
4811 xmalloc (sizeof (struct symtab_and_line
) * (ret
.nelts
-deleted
));
4813 for (i
= 0, j
= 0; i
< ret
.nelts
; ++i
)
4815 final
[j
++] = ret
.sals
[i
];
4817 ret
.nelts
-= deleted
;
4827 _initialize_symtab (void)
4829 add_info ("variables", variables_info
, _("\
4830 All global and static variable names, or those matching REGEXP."));
4832 add_com ("whereis", class_info
, variables_info
, _("\
4833 All global and static variable names, or those matching REGEXP."));
4835 add_info ("functions", functions_info
,
4836 _("All function names, or those matching REGEXP."));
4838 /* FIXME: This command has at least the following problems:
4839 1. It prints builtin types (in a very strange and confusing fashion).
4840 2. It doesn't print right, e.g. with
4841 typedef struct foo *FOO
4842 type_print prints "FOO" when we want to make it (in this situation)
4843 print "struct foo *".
4844 I also think "ptype" or "whatis" is more likely to be useful (but if
4845 there is much disagreement "info types" can be fixed). */
4846 add_info ("types", types_info
,
4847 _("All type names, or those matching REGEXP."));
4849 add_info ("sources", sources_info
,
4850 _("Source files in the program."));
4852 add_com ("rbreak", class_breakpoint
, rbreak_command
,
4853 _("Set a breakpoint for all functions matching REGEXP."));
4857 add_com ("lf", class_info
, sources_info
,
4858 _("Source files in the program"));
4859 add_com ("lg", class_info
, variables_info
, _("\
4860 All global and static variable names, or those matching REGEXP."));
4863 add_setshow_enum_cmd ("multiple-symbols", no_class
,
4864 multiple_symbols_modes
, &multiple_symbols_mode
,
4866 Set the debugger behavior when more than one symbol are possible matches\n\
4867 in an expression."), _("\
4868 Show how the debugger handles ambiguities in expressions."), _("\
4869 Valid values are \"ask\", \"all\", \"cancel\", and the default is \"all\"."),
4870 NULL
, NULL
, &setlist
, &showlist
);
4872 observer_attach_executable_changed (symtab_observer_executable_changed
);