1 /* Symbol table lookup for the GNU debugger, GDB.
3 Copyright (C) 1986-2014 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
30 #include "gdb_regex.h"
31 #include "expression.h"
36 #include "filenames.h" /* for FILENAME_CMP */
37 #include "objc-lang.h"
43 #include "cli/cli-utils.h"
47 #include "gdb_obstack.h"
49 #include "dictionary.h"
51 #include <sys/types.h>
56 #include "cp-support.h"
60 #include "macroscope.h"
62 #include "parser-defs.h"
64 /* Forward declarations for local functions. */
66 static void rbreak_command (char *, int);
68 static int find_line_common (struct linetable
*, int, int *, int);
70 static struct symbol
*lookup_symbol_aux (const char *name
,
71 const struct block
*block
,
72 const domain_enum domain
,
73 enum language language
,
74 struct field_of_this_result
*);
77 struct symbol
*lookup_local_symbol (const char *name
,
78 const struct block
*block
,
79 const domain_enum domain
,
80 enum language language
);
82 static struct symbol
*
83 lookup_symbol_in_objfile_symtabs (struct objfile
*objfile
,
84 int block_index
, const char *name
,
85 const domain_enum domain
);
88 struct symbol
*lookup_symbol_via_quick_fns (struct objfile
*objfile
,
91 const domain_enum domain
);
93 extern initialize_file_ftype _initialize_symtab
;
95 /* Program space key for finding name and language of "main". */
97 static const struct program_space_data
*main_progspace_key
;
99 /* Type of the data stored on the program space. */
103 /* Name of "main". */
107 /* Language of "main". */
109 enum language language_of_main
;
112 /* When non-zero, print debugging messages related to symtab creation. */
113 unsigned int symtab_create_debug
= 0;
115 /* Non-zero if a file may be known by two different basenames.
116 This is the uncommon case, and significantly slows down gdb.
117 Default set to "off" to not slow down the common case. */
118 int basenames_may_differ
= 0;
120 /* Allow the user to configure the debugger behavior with respect
121 to multiple-choice menus when more than one symbol matches during
124 const char multiple_symbols_ask
[] = "ask";
125 const char multiple_symbols_all
[] = "all";
126 const char multiple_symbols_cancel
[] = "cancel";
127 static const char *const multiple_symbols_modes
[] =
129 multiple_symbols_ask
,
130 multiple_symbols_all
,
131 multiple_symbols_cancel
,
134 static const char *multiple_symbols_mode
= multiple_symbols_all
;
136 /* Read-only accessor to AUTO_SELECT_MODE. */
139 multiple_symbols_select_mode (void)
141 return multiple_symbols_mode
;
144 /* Block in which the most recently searched-for symbol was found.
145 Might be better to make this a parameter to lookup_symbol and
148 const struct block
*block_found
;
150 /* Return the name of a domain_enum. */
153 domain_name (domain_enum e
)
157 case UNDEF_DOMAIN
: return "UNDEF_DOMAIN";
158 case VAR_DOMAIN
: return "VAR_DOMAIN";
159 case STRUCT_DOMAIN
: return "STRUCT_DOMAIN";
160 case MODULE_DOMAIN
: return "MODULE_DOMAIN";
161 case LABEL_DOMAIN
: return "LABEL_DOMAIN";
162 case COMMON_BLOCK_DOMAIN
: return "COMMON_BLOCK_DOMAIN";
163 default: gdb_assert_not_reached ("bad domain_enum");
167 /* Return the name of a search_domain . */
170 search_domain_name (enum search_domain e
)
174 case VARIABLES_DOMAIN
: return "VARIABLES_DOMAIN";
175 case FUNCTIONS_DOMAIN
: return "FUNCTIONS_DOMAIN";
176 case TYPES_DOMAIN
: return "TYPES_DOMAIN";
177 case ALL_DOMAIN
: return "ALL_DOMAIN";
178 default: gdb_assert_not_reached ("bad search_domain");
185 compunit_primary_filetab (const struct compunit_symtab
*cust
)
187 gdb_assert (COMPUNIT_FILETABS (cust
) != NULL
);
189 /* The primary file symtab is the first one in the list. */
190 return COMPUNIT_FILETABS (cust
);
196 compunit_language (const struct compunit_symtab
*cust
)
198 struct symtab
*symtab
= compunit_primary_filetab (cust
);
200 /* The language of the compunit symtab is the language of its primary
202 return SYMTAB_LANGUAGE (symtab
);
205 /* See whether FILENAME matches SEARCH_NAME using the rule that we
206 advertise to the user. (The manual's description of linespecs
207 describes what we advertise). Returns true if they match, false
211 compare_filenames_for_search (const char *filename
, const char *search_name
)
213 int len
= strlen (filename
);
214 size_t search_len
= strlen (search_name
);
216 if (len
< search_len
)
219 /* The tail of FILENAME must match. */
220 if (FILENAME_CMP (filename
+ len
- search_len
, search_name
) != 0)
223 /* Either the names must completely match, or the character
224 preceding the trailing SEARCH_NAME segment of FILENAME must be a
227 The check !IS_ABSOLUTE_PATH ensures SEARCH_NAME "/dir/file.c"
228 cannot match FILENAME "/path//dir/file.c" - as user has requested
229 absolute path. The sama applies for "c:\file.c" possibly
230 incorrectly hypothetically matching "d:\dir\c:\file.c".
232 The HAS_DRIVE_SPEC purpose is to make FILENAME "c:file.c"
233 compatible with SEARCH_NAME "file.c". In such case a compiler had
234 to put the "c:file.c" name into debug info. Such compatibility
235 works only on GDB built for DOS host. */
236 return (len
== search_len
237 || (!IS_ABSOLUTE_PATH (search_name
)
238 && IS_DIR_SEPARATOR (filename
[len
- search_len
- 1]))
239 || (HAS_DRIVE_SPEC (filename
)
240 && STRIP_DRIVE_SPEC (filename
) == &filename
[len
- search_len
]));
243 /* Check for a symtab of a specific name by searching some symtabs.
244 This is a helper function for callbacks of iterate_over_symtabs.
246 If NAME is not absolute, then REAL_PATH is NULL
247 If NAME is absolute, then REAL_PATH is the gdb_realpath form of NAME.
249 The return value, NAME, REAL_PATH, CALLBACK, and DATA
250 are identical to the `map_symtabs_matching_filename' method of
251 quick_symbol_functions.
253 FIRST and AFTER_LAST indicate the range of compunit symtabs to search.
254 Each symtab within the specified compunit symtab is also searched.
255 AFTER_LAST is one past the last compunit symtab to search; NULL means to
256 search until the end of the list. */
259 iterate_over_some_symtabs (const char *name
,
260 const char *real_path
,
261 int (*callback
) (struct symtab
*symtab
,
264 struct compunit_symtab
*first
,
265 struct compunit_symtab
*after_last
)
267 struct compunit_symtab
*cust
;
269 const char* base_name
= lbasename (name
);
271 for (cust
= first
; cust
!= NULL
&& cust
!= after_last
; cust
= cust
->next
)
273 ALL_COMPUNIT_FILETABS (cust
, s
)
275 if (compare_filenames_for_search (s
->filename
, name
))
277 if (callback (s
, data
))
282 /* Before we invoke realpath, which can get expensive when many
283 files are involved, do a quick comparison of the basenames. */
284 if (! basenames_may_differ
285 && FILENAME_CMP (base_name
, lbasename (s
->filename
)) != 0)
288 if (compare_filenames_for_search (symtab_to_fullname (s
), name
))
290 if (callback (s
, data
))
295 /* If the user gave us an absolute path, try to find the file in
296 this symtab and use its absolute path. */
297 if (real_path
!= NULL
)
299 const char *fullname
= symtab_to_fullname (s
);
301 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
302 gdb_assert (IS_ABSOLUTE_PATH (name
));
303 if (FILENAME_CMP (real_path
, fullname
) == 0)
305 if (callback (s
, data
))
316 /* Check for a symtab of a specific name; first in symtabs, then in
317 psymtabs. *If* there is no '/' in the name, a match after a '/'
318 in the symtab filename will also work.
320 Calls CALLBACK with each symtab that is found and with the supplied
321 DATA. If CALLBACK returns true, the search stops. */
324 iterate_over_symtabs (const char *name
,
325 int (*callback
) (struct symtab
*symtab
,
329 struct objfile
*objfile
;
330 char *real_path
= NULL
;
331 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
333 /* Here we are interested in canonicalizing an absolute path, not
334 absolutizing a relative path. */
335 if (IS_ABSOLUTE_PATH (name
))
337 real_path
= gdb_realpath (name
);
338 make_cleanup (xfree
, real_path
);
339 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
342 ALL_OBJFILES (objfile
)
344 if (iterate_over_some_symtabs (name
, real_path
, callback
, data
,
345 objfile
->compunit_symtabs
, NULL
))
347 do_cleanups (cleanups
);
352 /* Same search rules as above apply here, but now we look thru the
355 ALL_OBJFILES (objfile
)
358 && objfile
->sf
->qf
->map_symtabs_matching_filename (objfile
,
364 do_cleanups (cleanups
);
369 do_cleanups (cleanups
);
372 /* The callback function used by lookup_symtab. */
375 lookup_symtab_callback (struct symtab
*symtab
, void *data
)
377 struct symtab
**result_ptr
= data
;
379 *result_ptr
= symtab
;
383 /* A wrapper for iterate_over_symtabs that returns the first matching
387 lookup_symtab (const char *name
)
389 struct symtab
*result
= NULL
;
391 iterate_over_symtabs (name
, lookup_symtab_callback
, &result
);
396 /* Mangle a GDB method stub type. This actually reassembles the pieces of the
397 full method name, which consist of the class name (from T), the unadorned
398 method name from METHOD_ID, and the signature for the specific overload,
399 specified by SIGNATURE_ID. Note that this function is g++ specific. */
402 gdb_mangle_name (struct type
*type
, int method_id
, int signature_id
)
404 int mangled_name_len
;
406 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
407 struct fn_field
*method
= &f
[signature_id
];
408 const char *field_name
= TYPE_FN_FIELDLIST_NAME (type
, method_id
);
409 const char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, signature_id
);
410 const char *newname
= type_name_no_tag (type
);
412 /* Does the form of physname indicate that it is the full mangled name
413 of a constructor (not just the args)? */
414 int is_full_physname_constructor
;
417 int is_destructor
= is_destructor_name (physname
);
418 /* Need a new type prefix. */
419 char *const_prefix
= method
->is_const
? "C" : "";
420 char *volatile_prefix
= method
->is_volatile
? "V" : "";
422 int len
= (newname
== NULL
? 0 : strlen (newname
));
424 /* Nothing to do if physname already contains a fully mangled v3 abi name
425 or an operator name. */
426 if ((physname
[0] == '_' && physname
[1] == 'Z')
427 || is_operator_name (field_name
))
428 return xstrdup (physname
);
430 is_full_physname_constructor
= is_constructor_name (physname
);
432 is_constructor
= is_full_physname_constructor
433 || (newname
&& strcmp (field_name
, newname
) == 0);
436 is_destructor
= (strncmp (physname
, "__dt", 4) == 0);
438 if (is_destructor
|| is_full_physname_constructor
)
440 mangled_name
= (char *) xmalloc (strlen (physname
) + 1);
441 strcpy (mangled_name
, physname
);
447 xsnprintf (buf
, sizeof (buf
), "__%s%s", const_prefix
, volatile_prefix
);
449 else if (physname
[0] == 't' || physname
[0] == 'Q')
451 /* The physname for template and qualified methods already includes
453 xsnprintf (buf
, sizeof (buf
), "__%s%s", const_prefix
, volatile_prefix
);
459 xsnprintf (buf
, sizeof (buf
), "__%s%s%d", const_prefix
,
460 volatile_prefix
, len
);
462 mangled_name_len
= ((is_constructor
? 0 : strlen (field_name
))
463 + strlen (buf
) + len
+ strlen (physname
) + 1);
465 mangled_name
= (char *) xmalloc (mangled_name_len
);
467 mangled_name
[0] = '\0';
469 strcpy (mangled_name
, field_name
);
471 strcat (mangled_name
, buf
);
472 /* If the class doesn't have a name, i.e. newname NULL, then we just
473 mangle it using 0 for the length of the class. Thus it gets mangled
474 as something starting with `::' rather than `classname::'. */
476 strcat (mangled_name
, newname
);
478 strcat (mangled_name
, physname
);
479 return (mangled_name
);
482 /* Set the demangled name of GSYMBOL to NAME. NAME must be already
483 correctly allocated. */
486 symbol_set_demangled_name (struct general_symbol_info
*gsymbol
,
488 struct obstack
*obstack
)
490 if (gsymbol
->language
== language_ada
)
494 gsymbol
->ada_mangled
= 0;
495 gsymbol
->language_specific
.obstack
= obstack
;
499 gsymbol
->ada_mangled
= 1;
500 gsymbol
->language_specific
.mangled_lang
.demangled_name
= name
;
504 gsymbol
->language_specific
.mangled_lang
.demangled_name
= name
;
507 /* Return the demangled name of GSYMBOL. */
510 symbol_get_demangled_name (const struct general_symbol_info
*gsymbol
)
512 if (gsymbol
->language
== language_ada
)
514 if (!gsymbol
->ada_mangled
)
519 return gsymbol
->language_specific
.mangled_lang
.demangled_name
;
523 /* Initialize the language dependent portion of a symbol
524 depending upon the language for the symbol. */
527 symbol_set_language (struct general_symbol_info
*gsymbol
,
528 enum language language
,
529 struct obstack
*obstack
)
531 gsymbol
->language
= language
;
532 if (gsymbol
->language
== language_cplus
533 || gsymbol
->language
== language_d
534 || gsymbol
->language
== language_go
535 || gsymbol
->language
== language_java
536 || gsymbol
->language
== language_objc
537 || gsymbol
->language
== language_fortran
)
539 symbol_set_demangled_name (gsymbol
, NULL
, obstack
);
541 else if (gsymbol
->language
== language_ada
)
543 gdb_assert (gsymbol
->ada_mangled
== 0);
544 gsymbol
->language_specific
.obstack
= obstack
;
548 memset (&gsymbol
->language_specific
, 0,
549 sizeof (gsymbol
->language_specific
));
553 /* Functions to initialize a symbol's mangled name. */
555 /* Objects of this type are stored in the demangled name hash table. */
556 struct demangled_name_entry
562 /* Hash function for the demangled name hash. */
565 hash_demangled_name_entry (const void *data
)
567 const struct demangled_name_entry
*e
= data
;
569 return htab_hash_string (e
->mangled
);
572 /* Equality function for the demangled name hash. */
575 eq_demangled_name_entry (const void *a
, const void *b
)
577 const struct demangled_name_entry
*da
= a
;
578 const struct demangled_name_entry
*db
= b
;
580 return strcmp (da
->mangled
, db
->mangled
) == 0;
583 /* Create the hash table used for demangled names. Each hash entry is
584 a pair of strings; one for the mangled name and one for the demangled
585 name. The entry is hashed via just the mangled name. */
588 create_demangled_names_hash (struct objfile
*objfile
)
590 /* Choose 256 as the starting size of the hash table, somewhat arbitrarily.
591 The hash table code will round this up to the next prime number.
592 Choosing a much larger table size wastes memory, and saves only about
593 1% in symbol reading. */
595 objfile
->per_bfd
->demangled_names_hash
= htab_create_alloc
596 (256, hash_demangled_name_entry
, eq_demangled_name_entry
,
597 NULL
, xcalloc
, xfree
);
600 /* Try to determine the demangled name for a symbol, based on the
601 language of that symbol. If the language is set to language_auto,
602 it will attempt to find any demangling algorithm that works and
603 then set the language appropriately. The returned name is allocated
604 by the demangler and should be xfree'd. */
607 symbol_find_demangled_name (struct general_symbol_info
*gsymbol
,
610 char *demangled
= NULL
;
612 if (gsymbol
->language
== language_unknown
)
613 gsymbol
->language
= language_auto
;
615 if (gsymbol
->language
== language_objc
616 || gsymbol
->language
== language_auto
)
619 objc_demangle (mangled
, 0);
620 if (demangled
!= NULL
)
622 gsymbol
->language
= language_objc
;
626 if (gsymbol
->language
== language_cplus
627 || gsymbol
->language
== language_auto
)
630 gdb_demangle (mangled
, DMGL_PARAMS
| DMGL_ANSI
);
631 if (demangled
!= NULL
)
633 gsymbol
->language
= language_cplus
;
637 if (gsymbol
->language
== language_java
)
640 gdb_demangle (mangled
,
641 DMGL_PARAMS
| DMGL_ANSI
| DMGL_JAVA
);
642 if (demangled
!= NULL
)
644 gsymbol
->language
= language_java
;
648 if (gsymbol
->language
== language_d
649 || gsymbol
->language
== language_auto
)
651 demangled
= d_demangle(mangled
, 0);
652 if (demangled
!= NULL
)
654 gsymbol
->language
= language_d
;
658 /* FIXME(dje): Continually adding languages here is clumsy.
659 Better to just call la_demangle if !auto, and if auto then call
660 a utility routine that tries successive languages in turn and reports
661 which one it finds. I realize the la_demangle options may be different
662 for different languages but there's already a FIXME for that. */
663 if (gsymbol
->language
== language_go
664 || gsymbol
->language
== language_auto
)
666 demangled
= go_demangle (mangled
, 0);
667 if (demangled
!= NULL
)
669 gsymbol
->language
= language_go
;
674 /* We could support `gsymbol->language == language_fortran' here to provide
675 module namespaces also for inferiors with only minimal symbol table (ELF
676 symbols). Just the mangling standard is not standardized across compilers
677 and there is no DW_AT_producer available for inferiors with only the ELF
678 symbols to check the mangling kind. */
680 /* Check for Ada symbols last. See comment below explaining why. */
682 if (gsymbol
->language
== language_auto
)
684 const char *demangled
= ada_decode (mangled
);
686 if (demangled
!= mangled
&& demangled
!= NULL
&& demangled
[0] != '<')
688 /* Set the gsymbol language to Ada, but still return NULL.
689 Two reasons for that:
691 1. For Ada, we prefer computing the symbol's decoded name
692 on the fly rather than pre-compute it, in order to save
693 memory (Ada projects are typically very large).
695 2. There are some areas in the definition of the GNAT
696 encoding where, with a bit of bad luck, we might be able
697 to decode a non-Ada symbol, generating an incorrect
698 demangled name (Eg: names ending with "TB" for instance
699 are identified as task bodies and so stripped from
700 the decoded name returned).
702 Returning NULL, here, helps us get a little bit of
703 the best of both worlds. Because we're last, we should
704 not affect any of the other languages that were able to
705 demangle the symbol before us; we get to correctly tag
706 Ada symbols as such; and even if we incorrectly tagged
707 a non-Ada symbol, which should be rare, any routing
708 through the Ada language should be transparent (Ada
709 tries to behave much like C/C++ with non-Ada symbols). */
710 gsymbol
->language
= language_ada
;
718 /* Set both the mangled and demangled (if any) names for GSYMBOL based
719 on LINKAGE_NAME and LEN. Ordinarily, NAME is copied onto the
720 objfile's obstack; but if COPY_NAME is 0 and if NAME is
721 NUL-terminated, then this function assumes that NAME is already
722 correctly saved (either permanently or with a lifetime tied to the
723 objfile), and it will not be copied.
725 The hash table corresponding to OBJFILE is used, and the memory
726 comes from the per-BFD storage_obstack. LINKAGE_NAME is copied,
727 so the pointer can be discarded after calling this function. */
729 /* We have to be careful when dealing with Java names: when we run
730 into a Java minimal symbol, we don't know it's a Java symbol, so it
731 gets demangled as a C++ name. This is unfortunate, but there's not
732 much we can do about it: but when demangling partial symbols and
733 regular symbols, we'd better not reuse the wrong demangled name.
734 (See PR gdb/1039.) We solve this by putting a distinctive prefix
735 on Java names when storing them in the hash table. */
737 /* FIXME: carlton/2003-03-13: This is an unfortunate situation. I
738 don't mind the Java prefix so much: different languages have
739 different demangling requirements, so it's only natural that we
740 need to keep language data around in our demangling cache. But
741 it's not good that the minimal symbol has the wrong demangled name.
742 Unfortunately, I can't think of any easy solution to that
745 #define JAVA_PREFIX "##JAVA$$"
746 #define JAVA_PREFIX_LEN 8
749 symbol_set_names (struct general_symbol_info
*gsymbol
,
750 const char *linkage_name
, int len
, int copy_name
,
751 struct objfile
*objfile
)
753 struct demangled_name_entry
**slot
;
754 /* A 0-terminated copy of the linkage name. */
755 const char *linkage_name_copy
;
756 /* A copy of the linkage name that might have a special Java prefix
757 added to it, for use when looking names up in the hash table. */
758 const char *lookup_name
;
759 /* The length of lookup_name. */
761 struct demangled_name_entry entry
;
762 struct objfile_per_bfd_storage
*per_bfd
= objfile
->per_bfd
;
764 if (gsymbol
->language
== language_ada
)
766 /* In Ada, we do the symbol lookups using the mangled name, so
767 we can save some space by not storing the demangled name.
769 As a side note, we have also observed some overlap between
770 the C++ mangling and Ada mangling, similarly to what has
771 been observed with Java. Because we don't store the demangled
772 name with the symbol, we don't need to use the same trick
775 gsymbol
->name
= linkage_name
;
778 char *name
= obstack_alloc (&per_bfd
->storage_obstack
, len
+ 1);
780 memcpy (name
, linkage_name
, len
);
782 gsymbol
->name
= name
;
784 symbol_set_demangled_name (gsymbol
, NULL
, &per_bfd
->storage_obstack
);
789 if (per_bfd
->demangled_names_hash
== NULL
)
790 create_demangled_names_hash (objfile
);
792 /* The stabs reader generally provides names that are not
793 NUL-terminated; most of the other readers don't do this, so we
794 can just use the given copy, unless we're in the Java case. */
795 if (gsymbol
->language
== language_java
)
799 lookup_len
= len
+ JAVA_PREFIX_LEN
;
800 alloc_name
= alloca (lookup_len
+ 1);
801 memcpy (alloc_name
, JAVA_PREFIX
, JAVA_PREFIX_LEN
);
802 memcpy (alloc_name
+ JAVA_PREFIX_LEN
, linkage_name
, len
);
803 alloc_name
[lookup_len
] = '\0';
805 lookup_name
= alloc_name
;
806 linkage_name_copy
= alloc_name
+ JAVA_PREFIX_LEN
;
808 else if (linkage_name
[len
] != '\0')
813 alloc_name
= alloca (lookup_len
+ 1);
814 memcpy (alloc_name
, linkage_name
, len
);
815 alloc_name
[lookup_len
] = '\0';
817 lookup_name
= alloc_name
;
818 linkage_name_copy
= alloc_name
;
823 lookup_name
= linkage_name
;
824 linkage_name_copy
= linkage_name
;
827 entry
.mangled
= lookup_name
;
828 slot
= ((struct demangled_name_entry
**)
829 htab_find_slot (per_bfd
->demangled_names_hash
,
832 /* If this name is not in the hash table, add it. */
834 /* A C version of the symbol may have already snuck into the table.
835 This happens to, e.g., main.init (__go_init_main). Cope. */
836 || (gsymbol
->language
== language_go
837 && (*slot
)->demangled
[0] == '\0'))
839 char *demangled_name
= symbol_find_demangled_name (gsymbol
,
841 int demangled_len
= demangled_name
? strlen (demangled_name
) : 0;
843 /* Suppose we have demangled_name==NULL, copy_name==0, and
844 lookup_name==linkage_name. In this case, we already have the
845 mangled name saved, and we don't have a demangled name. So,
846 you might think we could save a little space by not recording
847 this in the hash table at all.
849 It turns out that it is actually important to still save such
850 an entry in the hash table, because storing this name gives
851 us better bcache hit rates for partial symbols. */
852 if (!copy_name
&& lookup_name
== linkage_name
)
854 *slot
= obstack_alloc (&per_bfd
->storage_obstack
,
855 offsetof (struct demangled_name_entry
,
857 + demangled_len
+ 1);
858 (*slot
)->mangled
= lookup_name
;
864 /* If we must copy the mangled name, put it directly after
865 the demangled name so we can have a single
867 *slot
= obstack_alloc (&per_bfd
->storage_obstack
,
868 offsetof (struct demangled_name_entry
,
870 + lookup_len
+ demangled_len
+ 2);
871 mangled_ptr
= &((*slot
)->demangled
[demangled_len
+ 1]);
872 strcpy (mangled_ptr
, lookup_name
);
873 (*slot
)->mangled
= mangled_ptr
;
876 if (demangled_name
!= NULL
)
878 strcpy ((*slot
)->demangled
, demangled_name
);
879 xfree (demangled_name
);
882 (*slot
)->demangled
[0] = '\0';
885 gsymbol
->name
= (*slot
)->mangled
+ lookup_len
- len
;
886 if ((*slot
)->demangled
[0] != '\0')
887 symbol_set_demangled_name (gsymbol
, (*slot
)->demangled
,
888 &per_bfd
->storage_obstack
);
890 symbol_set_demangled_name (gsymbol
, NULL
, &per_bfd
->storage_obstack
);
893 /* Return the source code name of a symbol. In languages where
894 demangling is necessary, this is the demangled name. */
897 symbol_natural_name (const struct general_symbol_info
*gsymbol
)
899 switch (gsymbol
->language
)
906 case language_fortran
:
907 if (symbol_get_demangled_name (gsymbol
) != NULL
)
908 return symbol_get_demangled_name (gsymbol
);
911 return ada_decode_symbol (gsymbol
);
915 return gsymbol
->name
;
918 /* Return the demangled name for a symbol based on the language for
919 that symbol. If no demangled name exists, return NULL. */
922 symbol_demangled_name (const struct general_symbol_info
*gsymbol
)
924 const char *dem_name
= NULL
;
926 switch (gsymbol
->language
)
933 case language_fortran
:
934 dem_name
= symbol_get_demangled_name (gsymbol
);
937 dem_name
= ada_decode_symbol (gsymbol
);
945 /* Return the search name of a symbol---generally the demangled or
946 linkage name of the symbol, depending on how it will be searched for.
947 If there is no distinct demangled name, then returns the same value
948 (same pointer) as SYMBOL_LINKAGE_NAME. */
951 symbol_search_name (const struct general_symbol_info
*gsymbol
)
953 if (gsymbol
->language
== language_ada
)
954 return gsymbol
->name
;
956 return symbol_natural_name (gsymbol
);
959 /* Initialize the structure fields to zero values. */
962 init_sal (struct symtab_and_line
*sal
)
964 memset (sal
, 0, sizeof (*sal
));
968 /* Return 1 if the two sections are the same, or if they could
969 plausibly be copies of each other, one in an original object
970 file and another in a separated debug file. */
973 matching_obj_sections (struct obj_section
*obj_first
,
974 struct obj_section
*obj_second
)
976 asection
*first
= obj_first
? obj_first
->the_bfd_section
: NULL
;
977 asection
*second
= obj_second
? obj_second
->the_bfd_section
: NULL
;
980 /* If they're the same section, then they match. */
984 /* If either is NULL, give up. */
985 if (first
== NULL
|| second
== NULL
)
988 /* This doesn't apply to absolute symbols. */
989 if (first
->owner
== NULL
|| second
->owner
== NULL
)
992 /* If they're in the same object file, they must be different sections. */
993 if (first
->owner
== second
->owner
)
996 /* Check whether the two sections are potentially corresponding. They must
997 have the same size, address, and name. We can't compare section indexes,
998 which would be more reliable, because some sections may have been
1000 if (bfd_get_section_size (first
) != bfd_get_section_size (second
))
1003 /* In-memory addresses may start at a different offset, relativize them. */
1004 if (bfd_get_section_vma (first
->owner
, first
)
1005 - bfd_get_start_address (first
->owner
)
1006 != bfd_get_section_vma (second
->owner
, second
)
1007 - bfd_get_start_address (second
->owner
))
1010 if (bfd_get_section_name (first
->owner
, first
) == NULL
1011 || bfd_get_section_name (second
->owner
, second
) == NULL
1012 || strcmp (bfd_get_section_name (first
->owner
, first
),
1013 bfd_get_section_name (second
->owner
, second
)) != 0)
1016 /* Otherwise check that they are in corresponding objfiles. */
1019 if (obj
->obfd
== first
->owner
)
1021 gdb_assert (obj
!= NULL
);
1023 if (obj
->separate_debug_objfile
!= NULL
1024 && obj
->separate_debug_objfile
->obfd
== second
->owner
)
1026 if (obj
->separate_debug_objfile_backlink
!= NULL
1027 && obj
->separate_debug_objfile_backlink
->obfd
== second
->owner
)
1036 expand_symtab_containing_pc (CORE_ADDR pc
, struct obj_section
*section
)
1038 struct objfile
*objfile
;
1039 struct bound_minimal_symbol msymbol
;
1041 /* If we know that this is not a text address, return failure. This is
1042 necessary because we loop based on texthigh and textlow, which do
1043 not include the data ranges. */
1044 msymbol
= lookup_minimal_symbol_by_pc_section (pc
, section
);
1046 && (MSYMBOL_TYPE (msymbol
.minsym
) == mst_data
1047 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_bss
1048 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_abs
1049 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_file_data
1050 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_file_bss
))
1053 ALL_OBJFILES (objfile
)
1055 struct compunit_symtab
*cust
= NULL
;
1058 cust
= objfile
->sf
->qf
->find_pc_sect_compunit_symtab (objfile
, msymbol
,
1065 /* Debug symbols usually don't have section information. We need to dig that
1066 out of the minimal symbols and stash that in the debug symbol. */
1069 fixup_section (struct general_symbol_info
*ginfo
,
1070 CORE_ADDR addr
, struct objfile
*objfile
)
1072 struct minimal_symbol
*msym
;
1074 /* First, check whether a minimal symbol with the same name exists
1075 and points to the same address. The address check is required
1076 e.g. on PowerPC64, where the minimal symbol for a function will
1077 point to the function descriptor, while the debug symbol will
1078 point to the actual function code. */
1079 msym
= lookup_minimal_symbol_by_pc_name (addr
, ginfo
->name
, objfile
);
1081 ginfo
->section
= MSYMBOL_SECTION (msym
);
1084 /* Static, function-local variables do appear in the linker
1085 (minimal) symbols, but are frequently given names that won't
1086 be found via lookup_minimal_symbol(). E.g., it has been
1087 observed in frv-uclinux (ELF) executables that a static,
1088 function-local variable named "foo" might appear in the
1089 linker symbols as "foo.6" or "foo.3". Thus, there is no
1090 point in attempting to extend the lookup-by-name mechanism to
1091 handle this case due to the fact that there can be multiple
1094 So, instead, search the section table when lookup by name has
1095 failed. The ``addr'' and ``endaddr'' fields may have already
1096 been relocated. If so, the relocation offset (i.e. the
1097 ANOFFSET value) needs to be subtracted from these values when
1098 performing the comparison. We unconditionally subtract it,
1099 because, when no relocation has been performed, the ANOFFSET
1100 value will simply be zero.
1102 The address of the symbol whose section we're fixing up HAS
1103 NOT BEEN adjusted (relocated) yet. It can't have been since
1104 the section isn't yet known and knowing the section is
1105 necessary in order to add the correct relocation value. In
1106 other words, we wouldn't even be in this function (attempting
1107 to compute the section) if it were already known.
1109 Note that it is possible to search the minimal symbols
1110 (subtracting the relocation value if necessary) to find the
1111 matching minimal symbol, but this is overkill and much less
1112 efficient. It is not necessary to find the matching minimal
1113 symbol, only its section.
1115 Note that this technique (of doing a section table search)
1116 can fail when unrelocated section addresses overlap. For
1117 this reason, we still attempt a lookup by name prior to doing
1118 a search of the section table. */
1120 struct obj_section
*s
;
1123 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1125 int idx
= s
- objfile
->sections
;
1126 CORE_ADDR offset
= ANOFFSET (objfile
->section_offsets
, idx
);
1131 if (obj_section_addr (s
) - offset
<= addr
1132 && addr
< obj_section_endaddr (s
) - offset
)
1134 ginfo
->section
= idx
;
1139 /* If we didn't find the section, assume it is in the first
1140 section. If there is no allocated section, then it hardly
1141 matters what we pick, so just pick zero. */
1145 ginfo
->section
= fallback
;
1150 fixup_symbol_section (struct symbol
*sym
, struct objfile
*objfile
)
1157 /* We either have an OBJFILE, or we can get at it from the sym's
1158 symtab. Anything else is a bug. */
1159 gdb_assert (objfile
|| SYMBOL_SYMTAB (sym
));
1161 if (objfile
== NULL
)
1162 objfile
= SYMBOL_OBJFILE (sym
);
1164 if (SYMBOL_OBJ_SECTION (objfile
, sym
))
1167 /* We should have an objfile by now. */
1168 gdb_assert (objfile
);
1170 switch (SYMBOL_CLASS (sym
))
1174 addr
= SYMBOL_VALUE_ADDRESS (sym
);
1177 addr
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
1181 /* Nothing else will be listed in the minsyms -- no use looking
1186 fixup_section (&sym
->ginfo
, addr
, objfile
);
1191 /* Compute the demangled form of NAME as used by the various symbol
1192 lookup functions. The result is stored in *RESULT_NAME. Returns a
1193 cleanup which can be used to clean up the result.
1195 For Ada, this function just sets *RESULT_NAME to NAME, unmodified.
1196 Normally, Ada symbol lookups are performed using the encoded name
1197 rather than the demangled name, and so it might seem to make sense
1198 for this function to return an encoded version of NAME.
1199 Unfortunately, we cannot do this, because this function is used in
1200 circumstances where it is not appropriate to try to encode NAME.
1201 For instance, when displaying the frame info, we demangle the name
1202 of each parameter, and then perform a symbol lookup inside our
1203 function using that demangled name. In Ada, certain functions
1204 have internally-generated parameters whose name contain uppercase
1205 characters. Encoding those name would result in those uppercase
1206 characters to become lowercase, and thus cause the symbol lookup
1210 demangle_for_lookup (const char *name
, enum language lang
,
1211 const char **result_name
)
1213 char *demangled_name
= NULL
;
1214 const char *modified_name
= NULL
;
1215 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, 0);
1217 modified_name
= name
;
1219 /* If we are using C++, D, Go, or Java, demangle the name before doing a
1220 lookup, so we can always binary search. */
1221 if (lang
== language_cplus
)
1223 demangled_name
= gdb_demangle (name
, DMGL_ANSI
| DMGL_PARAMS
);
1226 modified_name
= demangled_name
;
1227 make_cleanup (xfree
, demangled_name
);
1231 /* If we were given a non-mangled name, canonicalize it
1232 according to the language (so far only for C++). */
1233 demangled_name
= cp_canonicalize_string (name
);
1236 modified_name
= demangled_name
;
1237 make_cleanup (xfree
, demangled_name
);
1241 else if (lang
== language_java
)
1243 demangled_name
= gdb_demangle (name
,
1244 DMGL_ANSI
| DMGL_PARAMS
| DMGL_JAVA
);
1247 modified_name
= demangled_name
;
1248 make_cleanup (xfree
, demangled_name
);
1251 else if (lang
== language_d
)
1253 demangled_name
= d_demangle (name
, 0);
1256 modified_name
= demangled_name
;
1257 make_cleanup (xfree
, demangled_name
);
1260 else if (lang
== language_go
)
1262 demangled_name
= go_demangle (name
, 0);
1265 modified_name
= demangled_name
;
1266 make_cleanup (xfree
, demangled_name
);
1270 *result_name
= modified_name
;
1276 This function (or rather its subordinates) have a bunch of loops and
1277 it would seem to be attractive to put in some QUIT's (though I'm not really
1278 sure whether it can run long enough to be really important). But there
1279 are a few calls for which it would appear to be bad news to quit
1280 out of here: e.g., find_proc_desc in alpha-mdebug-tdep.c. (Note
1281 that there is C++ code below which can error(), but that probably
1282 doesn't affect these calls since they are looking for a known
1283 variable and thus can probably assume it will never hit the C++
1287 lookup_symbol_in_language (const char *name
, const struct block
*block
,
1288 const domain_enum domain
, enum language lang
,
1289 struct field_of_this_result
*is_a_field_of_this
)
1291 const char *modified_name
;
1292 struct symbol
*returnval
;
1293 struct cleanup
*cleanup
= demangle_for_lookup (name
, lang
, &modified_name
);
1295 returnval
= lookup_symbol_aux (modified_name
, block
, domain
, lang
,
1296 is_a_field_of_this
);
1297 do_cleanups (cleanup
);
1305 lookup_symbol (const char *name
, const struct block
*block
,
1307 struct field_of_this_result
*is_a_field_of_this
)
1309 return lookup_symbol_in_language (name
, block
, domain
,
1310 current_language
->la_language
,
1311 is_a_field_of_this
);
1317 lookup_language_this (const struct language_defn
*lang
,
1318 const struct block
*block
)
1320 if (lang
->la_name_of_this
== NULL
|| block
== NULL
)
1327 sym
= block_lookup_symbol (block
, lang
->la_name_of_this
, VAR_DOMAIN
);
1330 block_found
= block
;
1333 if (BLOCK_FUNCTION (block
))
1335 block
= BLOCK_SUPERBLOCK (block
);
1341 /* Given TYPE, a structure/union,
1342 return 1 if the component named NAME from the ultimate target
1343 structure/union is defined, otherwise, return 0. */
1346 check_field (struct type
*type
, const char *name
,
1347 struct field_of_this_result
*is_a_field_of_this
)
1351 /* The type may be a stub. */
1352 CHECK_TYPEDEF (type
);
1354 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1356 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1358 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1360 is_a_field_of_this
->type
= type
;
1361 is_a_field_of_this
->field
= &TYPE_FIELD (type
, i
);
1366 /* C++: If it was not found as a data field, then try to return it
1367 as a pointer to a method. */
1369 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
1371 if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type
, i
), name
) == 0)
1373 is_a_field_of_this
->type
= type
;
1374 is_a_field_of_this
->fn_field
= &TYPE_FN_FIELDLIST (type
, i
);
1379 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1380 if (check_field (TYPE_BASECLASS (type
, i
), name
, is_a_field_of_this
))
1386 /* Behave like lookup_symbol except that NAME is the natural name
1387 (e.g., demangled name) of the symbol that we're looking for. */
1389 static struct symbol
*
1390 lookup_symbol_aux (const char *name
, const struct block
*block
,
1391 const domain_enum domain
, enum language language
,
1392 struct field_of_this_result
*is_a_field_of_this
)
1395 const struct language_defn
*langdef
;
1397 /* Make sure we do something sensible with is_a_field_of_this, since
1398 the callers that set this parameter to some non-null value will
1399 certainly use it later. If we don't set it, the contents of
1400 is_a_field_of_this are undefined. */
1401 if (is_a_field_of_this
!= NULL
)
1402 memset (is_a_field_of_this
, 0, sizeof (*is_a_field_of_this
));
1404 /* Search specified block and its superiors. Don't search
1405 STATIC_BLOCK or GLOBAL_BLOCK. */
1407 sym
= lookup_local_symbol (name
, block
, domain
, language
);
1411 /* If requested to do so by the caller and if appropriate for LANGUAGE,
1412 check to see if NAME is a field of `this'. */
1414 langdef
= language_def (language
);
1416 /* Don't do this check if we are searching for a struct. It will
1417 not be found by check_field, but will be found by other
1419 if (is_a_field_of_this
!= NULL
&& domain
!= STRUCT_DOMAIN
)
1421 struct symbol
*sym
= lookup_language_this (langdef
, block
);
1425 struct type
*t
= sym
->type
;
1427 /* I'm not really sure that type of this can ever
1428 be typedefed; just be safe. */
1430 if (TYPE_CODE (t
) == TYPE_CODE_PTR
1431 || TYPE_CODE (t
) == TYPE_CODE_REF
)
1432 t
= TYPE_TARGET_TYPE (t
);
1434 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
1435 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1436 error (_("Internal error: `%s' is not an aggregate"),
1437 langdef
->la_name_of_this
);
1439 if (check_field (t
, name
, is_a_field_of_this
))
1444 /* Now do whatever is appropriate for LANGUAGE to look
1445 up static and global variables. */
1447 sym
= langdef
->la_lookup_symbol_nonlocal (name
, block
, domain
);
1451 /* Now search all static file-level symbols. Not strictly correct,
1452 but more useful than an error. */
1454 return lookup_static_symbol (name
, domain
);
1457 /* Check to see if the symbol is defined in BLOCK or its superiors.
1458 Don't search STATIC_BLOCK or GLOBAL_BLOCK. */
1460 static struct symbol
*
1461 lookup_local_symbol (const char *name
, const struct block
*block
,
1462 const domain_enum domain
,
1463 enum language language
)
1466 const struct block
*static_block
= block_static_block (block
);
1467 const char *scope
= block_scope (block
);
1469 /* Check if either no block is specified or it's a global block. */
1471 if (static_block
== NULL
)
1474 while (block
!= static_block
)
1476 sym
= lookup_symbol_in_block (name
, block
, domain
);
1480 if (language
== language_cplus
|| language
== language_fortran
)
1482 sym
= cp_lookup_symbol_imports_or_template (scope
, name
, block
,
1488 if (BLOCK_FUNCTION (block
) != NULL
&& block_inlined_p (block
))
1490 block
= BLOCK_SUPERBLOCK (block
);
1493 /* We've reached the end of the function without finding a result. */
1501 lookup_objfile_from_block (const struct block
*block
)
1503 struct objfile
*obj
;
1504 struct compunit_symtab
*cust
;
1509 block
= block_global_block (block
);
1510 /* Look through all blockvectors. */
1511 ALL_COMPUNITS (obj
, cust
)
1512 if (block
== BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
),
1515 if (obj
->separate_debug_objfile_backlink
)
1516 obj
= obj
->separate_debug_objfile_backlink
;
1527 lookup_symbol_in_block (const char *name
, const struct block
*block
,
1528 const domain_enum domain
)
1532 sym
= block_lookup_symbol (block
, name
, domain
);
1535 block_found
= block
;
1536 return fixup_symbol_section (sym
, NULL
);
1545 lookup_global_symbol_from_objfile (struct objfile
*main_objfile
,
1547 const domain_enum domain
)
1549 struct objfile
*objfile
;
1551 for (objfile
= main_objfile
;
1553 objfile
= objfile_separate_debug_iterate (main_objfile
, objfile
))
1557 sym
= lookup_symbol_in_objfile_symtabs (objfile
, GLOBAL_BLOCK
, name
,
1562 sym
= lookup_symbol_via_quick_fns (objfile
, GLOBAL_BLOCK
, name
, domain
);
1570 /* Check to see if the symbol is defined in one of the OBJFILE's
1571 symtabs. BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
1572 depending on whether or not we want to search global symbols or
1575 static struct symbol
*
1576 lookup_symbol_in_objfile_symtabs (struct objfile
*objfile
, int block_index
,
1577 const char *name
, const domain_enum domain
)
1579 struct compunit_symtab
*cust
;
1581 gdb_assert (block_index
== GLOBAL_BLOCK
|| block_index
== STATIC_BLOCK
);
1583 ALL_OBJFILE_COMPUNITS (objfile
, cust
)
1585 const struct blockvector
*bv
;
1586 const struct block
*block
;
1589 bv
= COMPUNIT_BLOCKVECTOR (cust
);
1590 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
1591 sym
= block_lookup_symbol_primary (block
, name
, domain
);
1594 block_found
= block
;
1595 return fixup_symbol_section (sym
, objfile
);
1602 /* Wrapper around lookup_symbol_in_objfile_symtabs for search_symbols.
1603 Look up LINKAGE_NAME in DOMAIN in the global and static blocks of OBJFILE
1604 and all associated separate debug objfiles.
1606 Normally we only look in OBJFILE, and not any separate debug objfiles
1607 because the outer loop will cause them to be searched too. This case is
1608 different. Here we're called from search_symbols where it will only
1609 call us for the the objfile that contains a matching minsym. */
1611 static struct symbol
*
1612 lookup_symbol_in_objfile_from_linkage_name (struct objfile
*objfile
,
1613 const char *linkage_name
,
1616 enum language lang
= current_language
->la_language
;
1617 const char *modified_name
;
1618 struct cleanup
*cleanup
= demangle_for_lookup (linkage_name
, lang
,
1620 struct objfile
*main_objfile
, *cur_objfile
;
1622 if (objfile
->separate_debug_objfile_backlink
)
1623 main_objfile
= objfile
->separate_debug_objfile_backlink
;
1625 main_objfile
= objfile
;
1627 for (cur_objfile
= main_objfile
;
1629 cur_objfile
= objfile_separate_debug_iterate (main_objfile
, cur_objfile
))
1633 sym
= lookup_symbol_in_objfile_symtabs (cur_objfile
, GLOBAL_BLOCK
,
1634 modified_name
, domain
);
1636 sym
= lookup_symbol_in_objfile_symtabs (cur_objfile
, STATIC_BLOCK
,
1637 modified_name
, domain
);
1640 do_cleanups (cleanup
);
1645 do_cleanups (cleanup
);
1649 /* A helper function that throws an exception when a symbol was found
1650 in a psymtab but not in a symtab. */
1652 static void ATTRIBUTE_NORETURN
1653 error_in_psymtab_expansion (int block_index
, const char *name
,
1654 struct compunit_symtab
*cust
)
1657 Internal: %s symbol `%s' found in %s psymtab but not in symtab.\n\
1658 %s may be an inlined function, or may be a template function\n \
1659 (if a template, try specifying an instantiation: %s<type>)."),
1660 block_index
== GLOBAL_BLOCK
? "global" : "static",
1662 symtab_to_filename_for_display (compunit_primary_filetab (cust
)),
1666 /* A helper function for various lookup routines that interfaces with
1667 the "quick" symbol table functions. */
1669 static struct symbol
*
1670 lookup_symbol_via_quick_fns (struct objfile
*objfile
, int block_index
,
1671 const char *name
, const domain_enum domain
)
1673 struct compunit_symtab
*cust
;
1674 const struct blockvector
*bv
;
1675 const struct block
*block
;
1680 cust
= objfile
->sf
->qf
->lookup_symbol (objfile
, block_index
, name
, domain
);
1684 bv
= COMPUNIT_BLOCKVECTOR (cust
);
1685 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
1686 sym
= block_lookup_symbol (block
, name
, domain
);
1688 error_in_psymtab_expansion (block_index
, name
, cust
);
1689 block_found
= block
;
1690 return fixup_symbol_section (sym
, objfile
);
1696 basic_lookup_symbol_nonlocal (const char *name
,
1697 const struct block
*block
,
1698 const domain_enum domain
)
1702 /* NOTE: carlton/2003-05-19: The comments below were written when
1703 this (or what turned into this) was part of lookup_symbol_aux;
1704 I'm much less worried about these questions now, since these
1705 decisions have turned out well, but I leave these comments here
1708 /* NOTE: carlton/2002-12-05: There is a question as to whether or
1709 not it would be appropriate to search the current global block
1710 here as well. (That's what this code used to do before the
1711 is_a_field_of_this check was moved up.) On the one hand, it's
1712 redundant with the lookup in all objfiles search that happens
1713 next. On the other hand, if decode_line_1 is passed an argument
1714 like filename:var, then the user presumably wants 'var' to be
1715 searched for in filename. On the third hand, there shouldn't be
1716 multiple global variables all of which are named 'var', and it's
1717 not like decode_line_1 has ever restricted its search to only
1718 global variables in a single filename. All in all, only
1719 searching the static block here seems best: it's correct and it's
1722 /* NOTE: carlton/2002-12-05: There's also a possible performance
1723 issue here: if you usually search for global symbols in the
1724 current file, then it would be slightly better to search the
1725 current global block before searching all the symtabs. But there
1726 are other factors that have a much greater effect on performance
1727 than that one, so I don't think we should worry about that for
1730 /* NOTE: dje/2014-10-26: The lookup in all objfiles search could skip
1731 the current objfile. Searching the current objfile first is useful
1732 for both matching user expectations as well as performance. */
1734 sym
= lookup_symbol_in_static_block (name
, block
, domain
);
1738 return lookup_global_symbol (name
, block
, domain
);
1744 lookup_symbol_in_static_block (const char *name
,
1745 const struct block
*block
,
1746 const domain_enum domain
)
1748 const struct block
*static_block
= block_static_block (block
);
1750 if (static_block
!= NULL
)
1751 return lookup_symbol_in_block (name
, static_block
, domain
);
1756 /* Perform the standard symbol lookup of NAME in OBJFILE:
1757 1) First search expanded symtabs, and if not found
1758 2) Search the "quick" symtabs (partial or .gdb_index).
1759 BLOCK_INDEX is one of GLOBAL_BLOCK or STATIC_BLOCK. */
1761 static struct symbol
*
1762 lookup_symbol_in_objfile (struct objfile
*objfile
, int block_index
,
1763 const char *name
, const domain_enum domain
)
1765 struct symbol
*result
;
1767 result
= lookup_symbol_in_objfile_symtabs (objfile
, block_index
,
1771 result
= lookup_symbol_via_quick_fns (objfile
, block_index
,
1781 lookup_static_symbol (const char *name
, const domain_enum domain
)
1783 struct objfile
*objfile
;
1784 struct symbol
*result
;
1786 ALL_OBJFILES (objfile
)
1788 result
= lookup_symbol_in_objfile (objfile
, STATIC_BLOCK
, name
, domain
);
1796 /* Private data to be used with lookup_symbol_global_iterator_cb. */
1798 struct global_sym_lookup_data
1800 /* The name of the symbol we are searching for. */
1803 /* The domain to use for our search. */
1806 /* The field where the callback should store the symbol if found.
1807 It should be initialized to NULL before the search is started. */
1808 struct symbol
*result
;
1811 /* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
1812 It searches by name for a symbol in the GLOBAL_BLOCK of the given
1813 OBJFILE. The arguments for the search are passed via CB_DATA,
1814 which in reality is a pointer to struct global_sym_lookup_data. */
1817 lookup_symbol_global_iterator_cb (struct objfile
*objfile
,
1820 struct global_sym_lookup_data
*data
=
1821 (struct global_sym_lookup_data
*) cb_data
;
1823 gdb_assert (data
->result
== NULL
);
1825 data
->result
= lookup_symbol_in_objfile (objfile
, GLOBAL_BLOCK
,
1826 data
->name
, data
->domain
);
1828 /* If we found a match, tell the iterator to stop. Otherwise,
1830 return (data
->result
!= NULL
);
1836 lookup_global_symbol (const char *name
,
1837 const struct block
*block
,
1838 const domain_enum domain
)
1840 struct symbol
*sym
= NULL
;
1841 struct objfile
*objfile
= NULL
;
1842 struct global_sym_lookup_data lookup_data
;
1844 /* Call library-specific lookup procedure. */
1845 objfile
= lookup_objfile_from_block (block
);
1846 if (objfile
!= NULL
)
1847 sym
= solib_global_lookup (objfile
, name
, domain
);
1851 memset (&lookup_data
, 0, sizeof (lookup_data
));
1852 lookup_data
.name
= name
;
1853 lookup_data
.domain
= domain
;
1854 gdbarch_iterate_over_objfiles_in_search_order
1855 (objfile
!= NULL
? get_objfile_arch (objfile
) : target_gdbarch (),
1856 lookup_symbol_global_iterator_cb
, &lookup_data
, objfile
);
1858 return lookup_data
.result
;
1862 symbol_matches_domain (enum language symbol_language
,
1863 domain_enum symbol_domain
,
1866 /* For C++ "struct foo { ... }" also defines a typedef for "foo".
1867 A Java class declaration also defines a typedef for the class.
1868 Similarly, any Ada type declaration implicitly defines a typedef. */
1869 if (symbol_language
== language_cplus
1870 || symbol_language
== language_d
1871 || symbol_language
== language_java
1872 || symbol_language
== language_ada
)
1874 if ((domain
== VAR_DOMAIN
|| domain
== STRUCT_DOMAIN
)
1875 && symbol_domain
== STRUCT_DOMAIN
)
1878 /* For all other languages, strict match is required. */
1879 return (symbol_domain
== domain
);
1885 lookup_transparent_type (const char *name
)
1887 return current_language
->la_lookup_transparent_type (name
);
1890 /* A helper for basic_lookup_transparent_type that interfaces with the
1891 "quick" symbol table functions. */
1893 static struct type
*
1894 basic_lookup_transparent_type_quick (struct objfile
*objfile
, int block_index
,
1897 struct compunit_symtab
*cust
;
1898 const struct blockvector
*bv
;
1899 struct block
*block
;
1904 cust
= objfile
->sf
->qf
->lookup_symbol (objfile
, block_index
, name
,
1909 bv
= COMPUNIT_BLOCKVECTOR (cust
);
1910 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
1911 sym
= block_lookup_symbol (block
, name
, STRUCT_DOMAIN
);
1913 error_in_psymtab_expansion (block_index
, name
, cust
);
1915 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1916 return SYMBOL_TYPE (sym
);
1921 /* The standard implementation of lookup_transparent_type. This code
1922 was modeled on lookup_symbol -- the parts not relevant to looking
1923 up types were just left out. In particular it's assumed here that
1924 types are available in STRUCT_DOMAIN and only in file-static or
1928 basic_lookup_transparent_type (const char *name
)
1931 struct compunit_symtab
*cust
;
1932 const struct blockvector
*bv
;
1933 struct objfile
*objfile
;
1934 struct block
*block
;
1937 /* Now search all the global symbols. Do the symtab's first, then
1938 check the psymtab's. If a psymtab indicates the existence
1939 of the desired name as a global, then do psymtab-to-symtab
1940 conversion on the fly and return the found symbol. */
1942 ALL_OBJFILES (objfile
)
1944 ALL_OBJFILE_COMPUNITS (objfile
, cust
)
1946 bv
= COMPUNIT_BLOCKVECTOR (cust
);
1947 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1948 sym
= block_lookup_symbol (block
, name
, STRUCT_DOMAIN
);
1949 if (sym
&& !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1951 return SYMBOL_TYPE (sym
);
1956 ALL_OBJFILES (objfile
)
1958 t
= basic_lookup_transparent_type_quick (objfile
, GLOBAL_BLOCK
, name
);
1963 /* Now search the static file-level symbols.
1964 Not strictly correct, but more useful than an error.
1965 Do the symtab's first, then
1966 check the psymtab's. If a psymtab indicates the existence
1967 of the desired name as a file-level static, then do psymtab-to-symtab
1968 conversion on the fly and return the found symbol. */
1970 ALL_OBJFILES (objfile
)
1972 ALL_OBJFILE_COMPUNITS (objfile
, cust
)
1974 bv
= COMPUNIT_BLOCKVECTOR (cust
);
1975 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1976 sym
= block_lookup_symbol (block
, name
, STRUCT_DOMAIN
);
1977 if (sym
&& !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1979 return SYMBOL_TYPE (sym
);
1984 ALL_OBJFILES (objfile
)
1986 t
= basic_lookup_transparent_type_quick (objfile
, STATIC_BLOCK
, name
);
1991 return (struct type
*) 0;
1994 /* Iterate over the symbols named NAME, matching DOMAIN, in BLOCK.
1996 For each symbol that matches, CALLBACK is called. The symbol and
1997 DATA are passed to the callback.
1999 If CALLBACK returns zero, the iteration ends. Otherwise, the
2000 search continues. */
2003 iterate_over_symbols (const struct block
*block
, const char *name
,
2004 const domain_enum domain
,
2005 symbol_found_callback_ftype
*callback
,
2008 struct block_iterator iter
;
2011 ALL_BLOCK_SYMBOLS_WITH_NAME (block
, name
, iter
, sym
)
2013 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym
),
2014 SYMBOL_DOMAIN (sym
), domain
))
2016 if (!callback (sym
, data
))
2022 /* Find the compunit symtab associated with PC and SECTION.
2023 This will read in debug info as necessary. */
2025 struct compunit_symtab
*
2026 find_pc_sect_compunit_symtab (CORE_ADDR pc
, struct obj_section
*section
)
2028 struct compunit_symtab
*cust
;
2029 struct compunit_symtab
*best_cust
= NULL
;
2030 struct objfile
*objfile
;
2031 CORE_ADDR distance
= 0;
2032 struct bound_minimal_symbol msymbol
;
2034 /* If we know that this is not a text address, return failure. This is
2035 necessary because we loop based on the block's high and low code
2036 addresses, which do not include the data ranges, and because
2037 we call find_pc_sect_psymtab which has a similar restriction based
2038 on the partial_symtab's texthigh and textlow. */
2039 msymbol
= lookup_minimal_symbol_by_pc_section (pc
, section
);
2041 && (MSYMBOL_TYPE (msymbol
.minsym
) == mst_data
2042 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_bss
2043 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_abs
2044 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_file_data
2045 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_file_bss
))
2048 /* Search all symtabs for the one whose file contains our address, and which
2049 is the smallest of all the ones containing the address. This is designed
2050 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
2051 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
2052 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
2054 This happens for native ecoff format, where code from included files
2055 gets its own symtab. The symtab for the included file should have
2056 been read in already via the dependency mechanism.
2057 It might be swifter to create several symtabs with the same name
2058 like xcoff does (I'm not sure).
2060 It also happens for objfiles that have their functions reordered.
2061 For these, the symtab we are looking for is not necessarily read in. */
2063 ALL_COMPUNITS (objfile
, cust
)
2066 const struct blockvector
*bv
;
2068 bv
= COMPUNIT_BLOCKVECTOR (cust
);
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
->sf
)
2084 struct compunit_symtab
*result
;
2087 = objfile
->sf
->qf
->find_pc_sect_compunit_symtab (objfile
,
2096 struct block_iterator iter
;
2097 struct symbol
*sym
= NULL
;
2099 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2101 fixup_symbol_section (sym
, objfile
);
2102 if (matching_obj_sections (SYMBOL_OBJ_SECTION (objfile
, sym
),
2107 continue; /* No symbol in this symtab matches
2110 distance
= BLOCK_END (b
) - BLOCK_START (b
);
2115 if (best_cust
!= NULL
)
2118 /* Not found in symtabs, search the "quick" symtabs (e.g. psymtabs). */
2120 ALL_OBJFILES (objfile
)
2122 struct compunit_symtab
*result
;
2126 result
= objfile
->sf
->qf
->find_pc_sect_compunit_symtab (objfile
,
2137 /* Find the compunit symtab associated with PC.
2138 This will read in debug info as necessary.
2139 Backward compatibility, no section. */
2141 struct compunit_symtab
*
2142 find_pc_compunit_symtab (CORE_ADDR pc
)
2144 return find_pc_sect_compunit_symtab (pc
, find_pc_mapped_section (pc
));
2148 /* Find the source file and line number for a given PC value and SECTION.
2149 Return a structure containing a symtab pointer, a line number,
2150 and a pc range for the entire source line.
2151 The value's .pc field is NOT the specified pc.
2152 NOTCURRENT nonzero means, if specified pc is on a line boundary,
2153 use the line that ends there. Otherwise, in that case, the line
2154 that begins there is used. */
2156 /* The big complication here is that a line may start in one file, and end just
2157 before the start of another file. This usually occurs when you #include
2158 code in the middle of a subroutine. To properly find the end of a line's PC
2159 range, we must search all symtabs associated with this compilation unit, and
2160 find the one whose first PC is closer than that of the next line in this
2163 /* If it's worth the effort, we could be using a binary search. */
2165 struct symtab_and_line
2166 find_pc_sect_line (CORE_ADDR pc
, struct obj_section
*section
, int notcurrent
)
2168 struct compunit_symtab
*cust
;
2169 struct symtab
*iter_s
;
2170 struct linetable
*l
;
2173 struct linetable_entry
*item
;
2174 struct symtab_and_line val
;
2175 const struct blockvector
*bv
;
2176 struct bound_minimal_symbol msymbol
;
2178 /* Info on best line seen so far, and where it starts, and its file. */
2180 struct linetable_entry
*best
= NULL
;
2181 CORE_ADDR best_end
= 0;
2182 struct symtab
*best_symtab
= 0;
2184 /* Store here the first line number
2185 of a file which contains the line at the smallest pc after PC.
2186 If we don't find a line whose range contains PC,
2187 we will use a line one less than this,
2188 with a range from the start of that file to the first line's pc. */
2189 struct linetable_entry
*alt
= NULL
;
2191 /* Info on best line seen in this file. */
2193 struct linetable_entry
*prev
;
2195 /* If this pc is not from the current frame,
2196 it is the address of the end of a call instruction.
2197 Quite likely that is the start of the following statement.
2198 But what we want is the statement containing the instruction.
2199 Fudge the pc to make sure we get that. */
2201 init_sal (&val
); /* initialize to zeroes */
2203 val
.pspace
= current_program_space
;
2205 /* It's tempting to assume that, if we can't find debugging info for
2206 any function enclosing PC, that we shouldn't search for line
2207 number info, either. However, GAS can emit line number info for
2208 assembly files --- very helpful when debugging hand-written
2209 assembly code. In such a case, we'd have no debug info for the
2210 function, but we would have line info. */
2215 /* elz: added this because this function returned the wrong
2216 information if the pc belongs to a stub (import/export)
2217 to call a shlib function. This stub would be anywhere between
2218 two functions in the target, and the line info was erroneously
2219 taken to be the one of the line before the pc. */
2221 /* RT: Further explanation:
2223 * We have stubs (trampolines) inserted between procedures.
2225 * Example: "shr1" exists in a shared library, and a "shr1" stub also
2226 * exists in the main image.
2228 * In the minimal symbol table, we have a bunch of symbols
2229 * sorted by start address. The stubs are marked as "trampoline",
2230 * the others appear as text. E.g.:
2232 * Minimal symbol table for main image
2233 * main: code for main (text symbol)
2234 * shr1: stub (trampoline symbol)
2235 * foo: code for foo (text symbol)
2237 * Minimal symbol table for "shr1" image:
2239 * shr1: code for shr1 (text symbol)
2242 * So the code below is trying to detect if we are in the stub
2243 * ("shr1" stub), and if so, find the real code ("shr1" trampoline),
2244 * and if found, do the symbolization from the real-code address
2245 * rather than the stub address.
2247 * Assumptions being made about the minimal symbol table:
2248 * 1. lookup_minimal_symbol_by_pc() will return a trampoline only
2249 * if we're really in the trampoline.s If we're beyond it (say
2250 * we're in "foo" in the above example), it'll have a closer
2251 * symbol (the "foo" text symbol for example) and will not
2252 * return the trampoline.
2253 * 2. lookup_minimal_symbol_text() will find a real text symbol
2254 * corresponding to the trampoline, and whose address will
2255 * be different than the trampoline address. I put in a sanity
2256 * check for the address being the same, to avoid an
2257 * infinite recursion.
2259 msymbol
= lookup_minimal_symbol_by_pc (pc
);
2260 if (msymbol
.minsym
!= NULL
)
2261 if (MSYMBOL_TYPE (msymbol
.minsym
) == mst_solib_trampoline
)
2263 struct bound_minimal_symbol mfunsym
2264 = lookup_minimal_symbol_text (MSYMBOL_LINKAGE_NAME (msymbol
.minsym
),
2267 if (mfunsym
.minsym
== NULL
)
2268 /* I eliminated this warning since it is coming out
2269 * in the following situation:
2270 * gdb shmain // test program with shared libraries
2271 * (gdb) break shr1 // function in shared lib
2272 * Warning: In stub for ...
2273 * In the above situation, the shared lib is not loaded yet,
2274 * so of course we can't find the real func/line info,
2275 * but the "break" still works, and the warning is annoying.
2276 * So I commented out the warning. RT */
2277 /* warning ("In stub for %s; unable to find real function/line info",
2278 SYMBOL_LINKAGE_NAME (msymbol)); */
2281 else if (BMSYMBOL_VALUE_ADDRESS (mfunsym
)
2282 == BMSYMBOL_VALUE_ADDRESS (msymbol
))
2283 /* Avoid infinite recursion */
2284 /* See above comment about why warning is commented out. */
2285 /* warning ("In stub for %s; unable to find real function/line info",
2286 SYMBOL_LINKAGE_NAME (msymbol)); */
2290 return find_pc_line (BMSYMBOL_VALUE_ADDRESS (mfunsym
), 0);
2294 cust
= find_pc_sect_compunit_symtab (pc
, section
);
2297 /* If no symbol information, return previous pc. */
2304 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2306 /* Look at all the symtabs that share this blockvector.
2307 They all have the same apriori range, that we found was right;
2308 but they have different line tables. */
2310 ALL_COMPUNIT_FILETABS (cust
, iter_s
)
2312 /* Find the best line in this symtab. */
2313 l
= SYMTAB_LINETABLE (iter_s
);
2319 /* I think len can be zero if the symtab lacks line numbers
2320 (e.g. gcc -g1). (Either that or the LINETABLE is NULL;
2321 I'm not sure which, and maybe it depends on the symbol
2327 item
= l
->item
; /* Get first line info. */
2329 /* Is this file's first line closer than the first lines of other files?
2330 If so, record this file, and its first line, as best alternate. */
2331 if (item
->pc
> pc
&& (!alt
|| item
->pc
< alt
->pc
))
2334 for (i
= 0; i
< len
; i
++, item
++)
2336 /* Leave prev pointing to the linetable entry for the last line
2337 that started at or before PC. */
2344 /* At this point, prev points at the line whose start addr is <= pc, and
2345 item points at the next line. If we ran off the end of the linetable
2346 (pc >= start of the last line), then prev == item. If pc < start of
2347 the first line, prev will not be set. */
2349 /* Is this file's best line closer than the best in the other files?
2350 If so, record this file, and its best line, as best so far. Don't
2351 save prev if it represents the end of a function (i.e. line number
2352 0) instead of a real line. */
2354 if (prev
&& prev
->line
&& (!best
|| prev
->pc
> best
->pc
))
2357 best_symtab
= iter_s
;
2359 /* Discard BEST_END if it's before the PC of the current BEST. */
2360 if (best_end
<= best
->pc
)
2364 /* If another line (denoted by ITEM) is in the linetable and its
2365 PC is after BEST's PC, but before the current BEST_END, then
2366 use ITEM's PC as the new best_end. */
2367 if (best
&& i
< len
&& item
->pc
> best
->pc
2368 && (best_end
== 0 || best_end
> item
->pc
))
2369 best_end
= item
->pc
;
2374 /* If we didn't find any line number info, just return zeros.
2375 We used to return alt->line - 1 here, but that could be
2376 anywhere; if we don't have line number info for this PC,
2377 don't make some up. */
2380 else if (best
->line
== 0)
2382 /* If our best fit is in a range of PC's for which no line
2383 number info is available (line number is zero) then we didn't
2384 find any valid line information. */
2389 val
.symtab
= best_symtab
;
2390 val
.line
= best
->line
;
2392 if (best_end
&& (!alt
|| best_end
< alt
->pc
))
2397 val
.end
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
2399 val
.section
= section
;
2403 /* Backward compatibility (no section). */
2405 struct symtab_and_line
2406 find_pc_line (CORE_ADDR pc
, int notcurrent
)
2408 struct obj_section
*section
;
2410 section
= find_pc_overlay (pc
);
2411 if (pc_in_unmapped_range (pc
, section
))
2412 pc
= overlay_mapped_address (pc
, section
);
2413 return find_pc_sect_line (pc
, section
, notcurrent
);
2419 find_pc_line_symtab (CORE_ADDR pc
)
2421 struct symtab_and_line sal
;
2423 /* This always passes zero for NOTCURRENT to find_pc_line.
2424 There are currently no callers that ever pass non-zero. */
2425 sal
= find_pc_line (pc
, 0);
2429 /* Find line number LINE in any symtab whose name is the same as
2432 If found, return the symtab that contains the linetable in which it was
2433 found, set *INDEX to the index in the linetable of the best entry
2434 found, and set *EXACT_MATCH nonzero if the value returned is an
2437 If not found, return NULL. */
2440 find_line_symtab (struct symtab
*symtab
, int line
,
2441 int *index
, int *exact_match
)
2443 int exact
= 0; /* Initialized here to avoid a compiler warning. */
2445 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
2449 struct linetable
*best_linetable
;
2450 struct symtab
*best_symtab
;
2452 /* First try looking it up in the given symtab. */
2453 best_linetable
= SYMTAB_LINETABLE (symtab
);
2454 best_symtab
= symtab
;
2455 best_index
= find_line_common (best_linetable
, line
, &exact
, 0);
2456 if (best_index
< 0 || !exact
)
2458 /* Didn't find an exact match. So we better keep looking for
2459 another symtab with the same name. In the case of xcoff,
2460 multiple csects for one source file (produced by IBM's FORTRAN
2461 compiler) produce multiple symtabs (this is unavoidable
2462 assuming csects can be at arbitrary places in memory and that
2463 the GLOBAL_BLOCK of a symtab has a begin and end address). */
2465 /* BEST is the smallest linenumber > LINE so far seen,
2466 or 0 if none has been seen so far.
2467 BEST_INDEX and BEST_LINETABLE identify the item for it. */
2470 struct objfile
*objfile
;
2471 struct compunit_symtab
*cu
;
2474 if (best_index
>= 0)
2475 best
= best_linetable
->item
[best_index
].line
;
2479 ALL_OBJFILES (objfile
)
2482 objfile
->sf
->qf
->expand_symtabs_with_fullname (objfile
,
2483 symtab_to_fullname (symtab
));
2486 ALL_FILETABS (objfile
, cu
, s
)
2488 struct linetable
*l
;
2491 if (FILENAME_CMP (symtab
->filename
, s
->filename
) != 0)
2493 if (FILENAME_CMP (symtab_to_fullname (symtab
),
2494 symtab_to_fullname (s
)) != 0)
2496 l
= SYMTAB_LINETABLE (s
);
2497 ind
= find_line_common (l
, line
, &exact
, 0);
2507 if (best
== 0 || l
->item
[ind
].line
< best
)
2509 best
= l
->item
[ind
].line
;
2522 *index
= best_index
;
2524 *exact_match
= exact
;
2529 /* Given SYMTAB, returns all the PCs function in the symtab that
2530 exactly match LINE. Returns NULL if there are no exact matches,
2531 but updates BEST_ITEM in this case. */
2534 find_pcs_for_symtab_line (struct symtab
*symtab
, int line
,
2535 struct linetable_entry
**best_item
)
2538 VEC (CORE_ADDR
) *result
= NULL
;
2540 /* First, collect all the PCs that are at this line. */
2546 idx
= find_line_common (SYMTAB_LINETABLE (symtab
), line
, &was_exact
,
2553 struct linetable_entry
*item
= &SYMTAB_LINETABLE (symtab
)->item
[idx
];
2555 if (*best_item
== NULL
|| item
->line
< (*best_item
)->line
)
2561 VEC_safe_push (CORE_ADDR
, result
,
2562 SYMTAB_LINETABLE (symtab
)->item
[idx
].pc
);
2570 /* Set the PC value for a given source file and line number and return true.
2571 Returns zero for invalid line number (and sets the PC to 0).
2572 The source file is specified with a struct symtab. */
2575 find_line_pc (struct symtab
*symtab
, int line
, CORE_ADDR
*pc
)
2577 struct linetable
*l
;
2584 symtab
= find_line_symtab (symtab
, line
, &ind
, NULL
);
2587 l
= SYMTAB_LINETABLE (symtab
);
2588 *pc
= l
->item
[ind
].pc
;
2595 /* Find the range of pc values in a line.
2596 Store the starting pc of the line into *STARTPTR
2597 and the ending pc (start of next line) into *ENDPTR.
2598 Returns 1 to indicate success.
2599 Returns 0 if could not find the specified line. */
2602 find_line_pc_range (struct symtab_and_line sal
, CORE_ADDR
*startptr
,
2605 CORE_ADDR startaddr
;
2606 struct symtab_and_line found_sal
;
2609 if (startaddr
== 0 && !find_line_pc (sal
.symtab
, sal
.line
, &startaddr
))
2612 /* This whole function is based on address. For example, if line 10 has
2613 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
2614 "info line *0x123" should say the line goes from 0x100 to 0x200
2615 and "info line *0x355" should say the line goes from 0x300 to 0x400.
2616 This also insures that we never give a range like "starts at 0x134
2617 and ends at 0x12c". */
2619 found_sal
= find_pc_sect_line (startaddr
, sal
.section
, 0);
2620 if (found_sal
.line
!= sal
.line
)
2622 /* The specified line (sal) has zero bytes. */
2623 *startptr
= found_sal
.pc
;
2624 *endptr
= found_sal
.pc
;
2628 *startptr
= found_sal
.pc
;
2629 *endptr
= found_sal
.end
;
2634 /* Given a line table and a line number, return the index into the line
2635 table for the pc of the nearest line whose number is >= the specified one.
2636 Return -1 if none is found. The value is >= 0 if it is an index.
2637 START is the index at which to start searching the line table.
2639 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
2642 find_line_common (struct linetable
*l
, int lineno
,
2643 int *exact_match
, int start
)
2648 /* BEST is the smallest linenumber > LINENO so far seen,
2649 or 0 if none has been seen so far.
2650 BEST_INDEX identifies the item for it. */
2652 int best_index
= -1;
2663 for (i
= start
; i
< len
; i
++)
2665 struct linetable_entry
*item
= &(l
->item
[i
]);
2667 if (item
->line
== lineno
)
2669 /* Return the first (lowest address) entry which matches. */
2674 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
2681 /* If we got here, we didn't get an exact match. */
2686 find_pc_line_pc_range (CORE_ADDR pc
, CORE_ADDR
*startptr
, CORE_ADDR
*endptr
)
2688 struct symtab_and_line sal
;
2690 sal
= find_pc_line (pc
, 0);
2693 return sal
.symtab
!= 0;
2696 /* Given a function symbol SYM, find the symtab and line for the start
2698 If the argument FUNFIRSTLINE is nonzero, we want the first line
2699 of real code inside the function. */
2701 struct symtab_and_line
2702 find_function_start_sal (struct symbol
*sym
, int funfirstline
)
2704 struct symtab_and_line sal
;
2706 fixup_symbol_section (sym
, NULL
);
2707 sal
= find_pc_sect_line (BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)),
2708 SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (sym
), sym
), 0);
2710 /* We always should have a line for the function start address.
2711 If we don't, something is odd. Create a plain SAL refering
2712 just the PC and hope that skip_prologue_sal (if requested)
2713 can find a line number for after the prologue. */
2714 if (sal
.pc
< BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)))
2717 sal
.pspace
= current_program_space
;
2718 sal
.pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
2719 sal
.section
= SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (sym
), sym
);
2723 skip_prologue_sal (&sal
);
2728 /* Given a function start address FUNC_ADDR and SYMTAB, find the first
2729 address for that function that has an entry in SYMTAB's line info
2730 table. If such an entry cannot be found, return FUNC_ADDR
2734 skip_prologue_using_lineinfo (CORE_ADDR func_addr
, struct symtab
*symtab
)
2736 CORE_ADDR func_start
, func_end
;
2737 struct linetable
*l
;
2740 /* Give up if this symbol has no lineinfo table. */
2741 l
= SYMTAB_LINETABLE (symtab
);
2745 /* Get the range for the function's PC values, or give up if we
2746 cannot, for some reason. */
2747 if (!find_pc_partial_function (func_addr
, NULL
, &func_start
, &func_end
))
2750 /* Linetable entries are ordered by PC values, see the commentary in
2751 symtab.h where `struct linetable' is defined. Thus, the first
2752 entry whose PC is in the range [FUNC_START..FUNC_END[ is the
2753 address we are looking for. */
2754 for (i
= 0; i
< l
->nitems
; i
++)
2756 struct linetable_entry
*item
= &(l
->item
[i
]);
2758 /* Don't use line numbers of zero, they mark special entries in
2759 the table. See the commentary on symtab.h before the
2760 definition of struct linetable. */
2761 if (item
->line
> 0 && func_start
<= item
->pc
&& item
->pc
< func_end
)
2768 /* Adjust SAL to the first instruction past the function prologue.
2769 If the PC was explicitly specified, the SAL is not changed.
2770 If the line number was explicitly specified, at most the SAL's PC
2771 is updated. If SAL is already past the prologue, then do nothing. */
2774 skip_prologue_sal (struct symtab_and_line
*sal
)
2777 struct symtab_and_line start_sal
;
2778 struct cleanup
*old_chain
;
2779 CORE_ADDR pc
, saved_pc
;
2780 struct obj_section
*section
;
2782 struct objfile
*objfile
;
2783 struct gdbarch
*gdbarch
;
2784 const struct block
*b
, *function_block
;
2785 int force_skip
, skip
;
2787 /* Do not change the SAL if PC was specified explicitly. */
2788 if (sal
->explicit_pc
)
2791 old_chain
= save_current_space_and_thread ();
2792 switch_to_program_space_and_thread (sal
->pspace
);
2794 sym
= find_pc_sect_function (sal
->pc
, sal
->section
);
2797 fixup_symbol_section (sym
, NULL
);
2799 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
2800 section
= SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (sym
), sym
);
2801 name
= SYMBOL_LINKAGE_NAME (sym
);
2802 objfile
= SYMBOL_OBJFILE (sym
);
2806 struct bound_minimal_symbol msymbol
2807 = lookup_minimal_symbol_by_pc_section (sal
->pc
, sal
->section
);
2809 if (msymbol
.minsym
== NULL
)
2811 do_cleanups (old_chain
);
2815 objfile
= msymbol
.objfile
;
2816 pc
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
2817 section
= MSYMBOL_OBJ_SECTION (objfile
, msymbol
.minsym
);
2818 name
= MSYMBOL_LINKAGE_NAME (msymbol
.minsym
);
2821 gdbarch
= get_objfile_arch (objfile
);
2823 /* Process the prologue in two passes. In the first pass try to skip the
2824 prologue (SKIP is true) and verify there is a real need for it (indicated
2825 by FORCE_SKIP). If no such reason was found run a second pass where the
2826 prologue is not skipped (SKIP is false). */
2831 /* Be conservative - allow direct PC (without skipping prologue) only if we
2832 have proven the CU (Compilation Unit) supports it. sal->SYMTAB does not
2833 have to be set by the caller so we use SYM instead. */
2834 if (sym
&& COMPUNIT_LOCATIONS_VALID (SYMTAB_COMPUNIT (SYMBOL_SYMTAB (sym
))))
2842 /* If the function is in an unmapped overlay, use its unmapped LMA address,
2843 so that gdbarch_skip_prologue has something unique to work on. */
2844 if (section_is_overlay (section
) && !section_is_mapped (section
))
2845 pc
= overlay_unmapped_address (pc
, section
);
2847 /* Skip "first line" of function (which is actually its prologue). */
2848 pc
+= gdbarch_deprecated_function_start_offset (gdbarch
);
2849 if (gdbarch_skip_entrypoint_p (gdbarch
))
2850 pc
= gdbarch_skip_entrypoint (gdbarch
, pc
);
2852 pc
= gdbarch_skip_prologue (gdbarch
, pc
);
2854 /* For overlays, map pc back into its mapped VMA range. */
2855 pc
= overlay_mapped_address (pc
, section
);
2857 /* Calculate line number. */
2858 start_sal
= find_pc_sect_line (pc
, section
, 0);
2860 /* Check if gdbarch_skip_prologue left us in mid-line, and the next
2861 line is still part of the same function. */
2862 if (skip
&& start_sal
.pc
!= pc
2863 && (sym
? (BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) <= start_sal
.end
2864 && start_sal
.end
< BLOCK_END (SYMBOL_BLOCK_VALUE (sym
)))
2865 : (lookup_minimal_symbol_by_pc_section (start_sal
.end
, section
).minsym
2866 == lookup_minimal_symbol_by_pc_section (pc
, section
).minsym
)))
2868 /* First pc of next line */
2870 /* Recalculate the line number (might not be N+1). */
2871 start_sal
= find_pc_sect_line (pc
, section
, 0);
2874 /* On targets with executable formats that don't have a concept of
2875 constructors (ELF with .init has, PE doesn't), gcc emits a call
2876 to `__main' in `main' between the prologue and before user
2878 if (gdbarch_skip_main_prologue_p (gdbarch
)
2879 && name
&& strcmp_iw (name
, "main") == 0)
2881 pc
= gdbarch_skip_main_prologue (gdbarch
, pc
);
2882 /* Recalculate the line number (might not be N+1). */
2883 start_sal
= find_pc_sect_line (pc
, section
, 0);
2887 while (!force_skip
&& skip
--);
2889 /* If we still don't have a valid source line, try to find the first
2890 PC in the lineinfo table that belongs to the same function. This
2891 happens with COFF debug info, which does not seem to have an
2892 entry in lineinfo table for the code after the prologue which has
2893 no direct relation to source. For example, this was found to be
2894 the case with the DJGPP target using "gcc -gcoff" when the
2895 compiler inserted code after the prologue to make sure the stack
2897 if (!force_skip
&& sym
&& start_sal
.symtab
== NULL
)
2899 pc
= skip_prologue_using_lineinfo (pc
, SYMBOL_SYMTAB (sym
));
2900 /* Recalculate the line number. */
2901 start_sal
= find_pc_sect_line (pc
, section
, 0);
2904 do_cleanups (old_chain
);
2906 /* If we're already past the prologue, leave SAL unchanged. Otherwise
2907 forward SAL to the end of the prologue. */
2912 sal
->section
= section
;
2914 /* Unless the explicit_line flag was set, update the SAL line
2915 and symtab to correspond to the modified PC location. */
2916 if (sal
->explicit_line
)
2919 sal
->symtab
= start_sal
.symtab
;
2920 sal
->line
= start_sal
.line
;
2921 sal
->end
= start_sal
.end
;
2923 /* Check if we are now inside an inlined function. If we can,
2924 use the call site of the function instead. */
2925 b
= block_for_pc_sect (sal
->pc
, sal
->section
);
2926 function_block
= NULL
;
2929 if (BLOCK_FUNCTION (b
) != NULL
&& block_inlined_p (b
))
2931 else if (BLOCK_FUNCTION (b
) != NULL
)
2933 b
= BLOCK_SUPERBLOCK (b
);
2935 if (function_block
!= NULL
2936 && SYMBOL_LINE (BLOCK_FUNCTION (function_block
)) != 0)
2938 sal
->line
= SYMBOL_LINE (BLOCK_FUNCTION (function_block
));
2939 sal
->symtab
= SYMBOL_SYMTAB (BLOCK_FUNCTION (function_block
));
2943 /* Given PC at the function's start address, attempt to find the
2944 prologue end using SAL information. Return zero if the skip fails.
2946 A non-optimized prologue traditionally has one SAL for the function
2947 and a second for the function body. A single line function has
2948 them both pointing at the same line.
2950 An optimized prologue is similar but the prologue may contain
2951 instructions (SALs) from the instruction body. Need to skip those
2952 while not getting into the function body.
2954 The functions end point and an increasing SAL line are used as
2955 indicators of the prologue's endpoint.
2957 This code is based on the function refine_prologue_limit
2961 skip_prologue_using_sal (struct gdbarch
*gdbarch
, CORE_ADDR func_addr
)
2963 struct symtab_and_line prologue_sal
;
2966 const struct block
*bl
;
2968 /* Get an initial range for the function. */
2969 find_pc_partial_function (func_addr
, NULL
, &start_pc
, &end_pc
);
2970 start_pc
+= gdbarch_deprecated_function_start_offset (gdbarch
);
2972 prologue_sal
= find_pc_line (start_pc
, 0);
2973 if (prologue_sal
.line
!= 0)
2975 /* For languages other than assembly, treat two consecutive line
2976 entries at the same address as a zero-instruction prologue.
2977 The GNU assembler emits separate line notes for each instruction
2978 in a multi-instruction macro, but compilers generally will not
2980 if (prologue_sal
.symtab
->language
!= language_asm
)
2982 struct linetable
*linetable
= SYMTAB_LINETABLE (prologue_sal
.symtab
);
2985 /* Skip any earlier lines, and any end-of-sequence marker
2986 from a previous function. */
2987 while (linetable
->item
[idx
].pc
!= prologue_sal
.pc
2988 || linetable
->item
[idx
].line
== 0)
2991 if (idx
+1 < linetable
->nitems
2992 && linetable
->item
[idx
+1].line
!= 0
2993 && linetable
->item
[idx
+1].pc
== start_pc
)
2997 /* If there is only one sal that covers the entire function,
2998 then it is probably a single line function, like
3000 if (prologue_sal
.end
>= end_pc
)
3003 while (prologue_sal
.end
< end_pc
)
3005 struct symtab_and_line sal
;
3007 sal
= find_pc_line (prologue_sal
.end
, 0);
3010 /* Assume that a consecutive SAL for the same (or larger)
3011 line mark the prologue -> body transition. */
3012 if (sal
.line
>= prologue_sal
.line
)
3014 /* Likewise if we are in a different symtab altogether
3015 (e.g. within a file included via #include). */
3016 if (sal
.symtab
!= prologue_sal
.symtab
)
3019 /* The line number is smaller. Check that it's from the
3020 same function, not something inlined. If it's inlined,
3021 then there is no point comparing the line numbers. */
3022 bl
= block_for_pc (prologue_sal
.end
);
3025 if (block_inlined_p (bl
))
3027 if (BLOCK_FUNCTION (bl
))
3032 bl
= BLOCK_SUPERBLOCK (bl
);
3037 /* The case in which compiler's optimizer/scheduler has
3038 moved instructions into the prologue. We look ahead in
3039 the function looking for address ranges whose
3040 corresponding line number is less the first one that we
3041 found for the function. This is more conservative then
3042 refine_prologue_limit which scans a large number of SALs
3043 looking for any in the prologue. */
3048 if (prologue_sal
.end
< end_pc
)
3049 /* Return the end of this line, or zero if we could not find a
3051 return prologue_sal
.end
;
3053 /* Don't return END_PC, which is past the end of the function. */
3054 return prologue_sal
.pc
;
3057 /* If P is of the form "operator[ \t]+..." where `...' is
3058 some legitimate operator text, return a pointer to the
3059 beginning of the substring of the operator text.
3060 Otherwise, return "". */
3063 operator_chars (const char *p
, const char **end
)
3066 if (strncmp (p
, "operator", 8))
3070 /* Don't get faked out by `operator' being part of a longer
3072 if (isalpha (*p
) || *p
== '_' || *p
== '$' || *p
== '\0')
3075 /* Allow some whitespace between `operator' and the operator symbol. */
3076 while (*p
== ' ' || *p
== '\t')
3079 /* Recognize 'operator TYPENAME'. */
3081 if (isalpha (*p
) || *p
== '_' || *p
== '$')
3083 const char *q
= p
+ 1;
3085 while (isalnum (*q
) || *q
== '_' || *q
== '$')
3094 case '\\': /* regexp quoting */
3097 if (p
[2] == '=') /* 'operator\*=' */
3099 else /* 'operator\*' */
3103 else if (p
[1] == '[')
3106 error (_("mismatched quoting on brackets, "
3107 "try 'operator\\[\\]'"));
3108 else if (p
[2] == '\\' && p
[3] == ']')
3110 *end
= p
+ 4; /* 'operator\[\]' */
3114 error (_("nothing is allowed between '[' and ']'"));
3118 /* Gratuitous qoute: skip it and move on. */
3140 if (p
[0] == '-' && p
[1] == '>')
3142 /* Struct pointer member operator 'operator->'. */
3145 *end
= p
+ 3; /* 'operator->*' */
3148 else if (p
[2] == '\\')
3150 *end
= p
+ 4; /* Hopefully 'operator->\*' */
3155 *end
= p
+ 2; /* 'operator->' */
3159 if (p
[1] == '=' || p
[1] == p
[0])
3170 error (_("`operator ()' must be specified "
3171 "without whitespace in `()'"));
3176 error (_("`operator ?:' must be specified "
3177 "without whitespace in `?:'"));
3182 error (_("`operator []' must be specified "
3183 "without whitespace in `[]'"));
3187 error (_("`operator %s' not supported"), p
);
3196 /* Cache to watch for file names already seen by filename_seen. */
3198 struct filename_seen_cache
3200 /* Table of files seen so far. */
3202 /* Initial size of the table. It automagically grows from here. */
3203 #define INITIAL_FILENAME_SEEN_CACHE_SIZE 100
3206 /* filename_seen_cache constructor. */
3208 static struct filename_seen_cache
*
3209 create_filename_seen_cache (void)
3211 struct filename_seen_cache
*cache
;
3213 cache
= XNEW (struct filename_seen_cache
);
3214 cache
->tab
= htab_create_alloc (INITIAL_FILENAME_SEEN_CACHE_SIZE
,
3215 filename_hash
, filename_eq
,
3216 NULL
, xcalloc
, xfree
);
3221 /* Empty the cache, but do not delete it. */
3224 clear_filename_seen_cache (struct filename_seen_cache
*cache
)
3226 htab_empty (cache
->tab
);
3229 /* filename_seen_cache destructor.
3230 This takes a void * argument as it is generally used as a cleanup. */
3233 delete_filename_seen_cache (void *ptr
)
3235 struct filename_seen_cache
*cache
= ptr
;
3237 htab_delete (cache
->tab
);
3241 /* If FILE is not already in the table of files in CACHE, return zero;
3242 otherwise return non-zero. Optionally add FILE to the table if ADD
3245 NOTE: We don't manage space for FILE, we assume FILE lives as long
3246 as the caller needs. */
3249 filename_seen (struct filename_seen_cache
*cache
, const char *file
, int add
)
3253 /* Is FILE in tab? */
3254 slot
= htab_find_slot (cache
->tab
, file
, add
? INSERT
: NO_INSERT
);
3258 /* No; maybe add it to tab. */
3260 *slot
= (char *) file
;
3265 /* Data structure to maintain printing state for output_source_filename. */
3267 struct output_source_filename_data
3269 /* Cache of what we've seen so far. */
3270 struct filename_seen_cache
*filename_seen_cache
;
3272 /* Flag of whether we're printing the first one. */
3276 /* Slave routine for sources_info. Force line breaks at ,'s.
3277 NAME is the name to print.
3278 DATA contains the state for printing and watching for duplicates. */
3281 output_source_filename (const char *name
,
3282 struct output_source_filename_data
*data
)
3284 /* Since a single source file can result in several partial symbol
3285 tables, we need to avoid printing it more than once. Note: if
3286 some of the psymtabs are read in and some are not, it gets
3287 printed both under "Source files for which symbols have been
3288 read" and "Source files for which symbols will be read in on
3289 demand". I consider this a reasonable way to deal with the
3290 situation. I'm not sure whether this can also happen for
3291 symtabs; it doesn't hurt to check. */
3293 /* Was NAME already seen? */
3294 if (filename_seen (data
->filename_seen_cache
, name
, 1))
3296 /* Yes; don't print it again. */
3300 /* No; print it and reset *FIRST. */
3302 printf_filtered (", ");
3306 fputs_filtered (name
, gdb_stdout
);
3309 /* A callback for map_partial_symbol_filenames. */
3312 output_partial_symbol_filename (const char *filename
, const char *fullname
,
3315 output_source_filename (fullname
? fullname
: filename
, data
);
3319 sources_info (char *ignore
, int from_tty
)
3321 struct compunit_symtab
*cu
;
3323 struct objfile
*objfile
;
3324 struct output_source_filename_data data
;
3325 struct cleanup
*cleanups
;
3327 if (!have_full_symbols () && !have_partial_symbols ())
3329 error (_("No symbol table is loaded. Use the \"file\" command."));
3332 data
.filename_seen_cache
= create_filename_seen_cache ();
3333 cleanups
= make_cleanup (delete_filename_seen_cache
,
3334 data
.filename_seen_cache
);
3336 printf_filtered ("Source files for which symbols have been read in:\n\n");
3339 ALL_FILETABS (objfile
, cu
, s
)
3341 const char *fullname
= symtab_to_fullname (s
);
3343 output_source_filename (fullname
, &data
);
3345 printf_filtered ("\n\n");
3347 printf_filtered ("Source files for which symbols "
3348 "will be read in on demand:\n\n");
3350 clear_filename_seen_cache (data
.filename_seen_cache
);
3352 map_symbol_filenames (output_partial_symbol_filename
, &data
,
3353 1 /*need_fullname*/);
3354 printf_filtered ("\n");
3356 do_cleanups (cleanups
);
3359 /* Compare FILE against all the NFILES entries of FILES. If BASENAMES is
3360 non-zero compare only lbasename of FILES. */
3363 file_matches (const char *file
, const char *files
[], int nfiles
, int basenames
)
3367 if (file
!= NULL
&& nfiles
!= 0)
3369 for (i
= 0; i
< nfiles
; i
++)
3371 if (compare_filenames_for_search (file
, (basenames
3372 ? lbasename (files
[i
])
3377 else if (nfiles
== 0)
3382 /* Free any memory associated with a search. */
3385 free_search_symbols (struct symbol_search
*symbols
)
3387 struct symbol_search
*p
;
3388 struct symbol_search
*next
;
3390 for (p
= symbols
; p
!= NULL
; p
= next
)
3398 do_free_search_symbols_cleanup (void *symbolsp
)
3400 struct symbol_search
*symbols
= *(struct symbol_search
**) symbolsp
;
3402 free_search_symbols (symbols
);
3406 make_cleanup_free_search_symbols (struct symbol_search
**symbolsp
)
3408 return make_cleanup (do_free_search_symbols_cleanup
, symbolsp
);
3411 /* Helper function for sort_search_symbols_remove_dups and qsort. Can only
3412 sort symbols, not minimal symbols. */
3415 compare_search_syms (const void *sa
, const void *sb
)
3417 struct symbol_search
*sym_a
= *(struct symbol_search
**) sa
;
3418 struct symbol_search
*sym_b
= *(struct symbol_search
**) sb
;
3421 c
= FILENAME_CMP (sym_a
->symtab
->filename
, sym_b
->symtab
->filename
);
3425 if (sym_a
->block
!= sym_b
->block
)
3426 return sym_a
->block
- sym_b
->block
;
3428 return strcmp (SYMBOL_PRINT_NAME (sym_a
->symbol
),
3429 SYMBOL_PRINT_NAME (sym_b
->symbol
));
3432 /* Sort the NFOUND symbols in list FOUND and remove duplicates.
3433 The duplicates are freed, and the new list is returned in
3434 *NEW_HEAD, *NEW_TAIL. */
3437 sort_search_symbols_remove_dups (struct symbol_search
*found
, int nfound
,
3438 struct symbol_search
**new_head
,
3439 struct symbol_search
**new_tail
)
3441 struct symbol_search
**symbols
, *symp
, *old_next
;
3444 gdb_assert (found
!= NULL
&& nfound
> 0);
3446 /* Build an array out of the list so we can easily sort them. */
3447 symbols
= (struct symbol_search
**) xmalloc (sizeof (struct symbol_search
*)
3450 for (i
= 0; i
< nfound
; i
++)
3452 gdb_assert (symp
!= NULL
);
3453 gdb_assert (symp
->block
>= 0 && symp
->block
<= 1);
3457 gdb_assert (symp
== NULL
);
3459 qsort (symbols
, nfound
, sizeof (struct symbol_search
*),
3460 compare_search_syms
);
3462 /* Collapse out the dups. */
3463 for (i
= 1, j
= 1; i
< nfound
; ++i
)
3465 if (compare_search_syms (&symbols
[j
- 1], &symbols
[i
]) != 0)
3466 symbols
[j
++] = symbols
[i
];
3471 symbols
[j
- 1]->next
= NULL
;
3473 /* Rebuild the linked list. */
3474 for (i
= 0; i
< nunique
- 1; i
++)
3475 symbols
[i
]->next
= symbols
[i
+ 1];
3476 symbols
[nunique
- 1]->next
= NULL
;
3478 *new_head
= symbols
[0];
3479 *new_tail
= symbols
[nunique
- 1];
3483 /* An object of this type is passed as the user_data to the
3484 expand_symtabs_matching method. */
3485 struct search_symbols_data
3490 /* It is true if PREG contains valid data, false otherwise. */
3491 unsigned preg_p
: 1;
3495 /* A callback for expand_symtabs_matching. */
3498 search_symbols_file_matches (const char *filename
, void *user_data
,
3501 struct search_symbols_data
*data
= user_data
;
3503 return file_matches (filename
, data
->files
, data
->nfiles
, basenames
);
3506 /* A callback for expand_symtabs_matching. */
3509 search_symbols_name_matches (const char *symname
, void *user_data
)
3511 struct search_symbols_data
*data
= user_data
;
3513 return !data
->preg_p
|| regexec (&data
->preg
, symname
, 0, NULL
, 0) == 0;
3516 /* Search the symbol table for matches to the regular expression REGEXP,
3517 returning the results in *MATCHES.
3519 Only symbols of KIND are searched:
3520 VARIABLES_DOMAIN - search all symbols, excluding functions, type names,
3521 and constants (enums)
3522 FUNCTIONS_DOMAIN - search all functions
3523 TYPES_DOMAIN - search all type names
3524 ALL_DOMAIN - an internal error for this function
3526 free_search_symbols should be called when *MATCHES is no longer needed.
3528 Within each file the results are sorted locally; each symtab's global and
3529 static blocks are separately alphabetized.
3530 Duplicate entries are removed. */
3533 search_symbols (const char *regexp
, enum search_domain kind
,
3534 int nfiles
, const char *files
[],
3535 struct symbol_search
**matches
)
3537 struct compunit_symtab
*cust
;
3538 const struct blockvector
*bv
;
3541 struct block_iterator iter
;
3543 struct objfile
*objfile
;
3544 struct minimal_symbol
*msymbol
;
3546 static const enum minimal_symbol_type types
[]
3547 = {mst_data
, mst_text
, mst_abs
};
3548 static const enum minimal_symbol_type types2
[]
3549 = {mst_bss
, mst_file_text
, mst_abs
};
3550 static const enum minimal_symbol_type types3
[]
3551 = {mst_file_data
, mst_solib_trampoline
, mst_abs
};
3552 static const enum minimal_symbol_type types4
[]
3553 = {mst_file_bss
, mst_text_gnu_ifunc
, mst_abs
};
3554 enum minimal_symbol_type ourtype
;
3555 enum minimal_symbol_type ourtype2
;
3556 enum minimal_symbol_type ourtype3
;
3557 enum minimal_symbol_type ourtype4
;
3558 struct symbol_search
*found
;
3559 struct symbol_search
*tail
;
3560 struct search_symbols_data datum
;
3563 /* OLD_CHAIN .. RETVAL_CHAIN is always freed, RETVAL_CHAIN .. current
3564 CLEANUP_CHAIN is freed only in the case of an error. */
3565 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
3566 struct cleanup
*retval_chain
;
3568 gdb_assert (kind
<= TYPES_DOMAIN
);
3570 ourtype
= types
[kind
];
3571 ourtype2
= types2
[kind
];
3572 ourtype3
= types3
[kind
];
3573 ourtype4
= types4
[kind
];
3580 /* Make sure spacing is right for C++ operators.
3581 This is just a courtesy to make the matching less sensitive
3582 to how many spaces the user leaves between 'operator'
3583 and <TYPENAME> or <OPERATOR>. */
3585 const char *opname
= operator_chars (regexp
, &opend
);
3590 int fix
= -1; /* -1 means ok; otherwise number of
3593 if (isalpha (*opname
) || *opname
== '_' || *opname
== '$')
3595 /* There should 1 space between 'operator' and 'TYPENAME'. */
3596 if (opname
[-1] != ' ' || opname
[-2] == ' ')
3601 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
3602 if (opname
[-1] == ' ')
3605 /* If wrong number of spaces, fix it. */
3608 char *tmp
= (char *) alloca (8 + fix
+ strlen (opname
) + 1);
3610 sprintf (tmp
, "operator%.*s%s", fix
, " ", opname
);
3615 errcode
= regcomp (&datum
.preg
, regexp
,
3616 REG_NOSUB
| (case_sensitivity
== case_sensitive_off
3620 char *err
= get_regcomp_error (errcode
, &datum
.preg
);
3622 make_cleanup (xfree
, err
);
3623 error (_("Invalid regexp (%s): %s"), err
, regexp
);
3626 make_regfree_cleanup (&datum
.preg
);
3629 /* Search through the partial symtabs *first* for all symbols
3630 matching the regexp. That way we don't have to reproduce all of
3631 the machinery below. */
3633 datum
.nfiles
= nfiles
;
3634 datum
.files
= files
;
3635 expand_symtabs_matching ((nfiles
== 0
3637 : search_symbols_file_matches
),
3638 search_symbols_name_matches
,
3641 /* Here, we search through the minimal symbol tables for functions
3642 and variables that match, and force their symbols to be read.
3643 This is in particular necessary for demangled variable names,
3644 which are no longer put into the partial symbol tables.
3645 The symbol will then be found during the scan of symtabs below.
3647 For functions, find_pc_symtab should succeed if we have debug info
3648 for the function, for variables we have to call
3649 lookup_symbol_in_objfile_from_linkage_name to determine if the variable
3651 If the lookup fails, set found_misc so that we will rescan to print
3652 any matching symbols without debug info.
3653 We only search the objfile the msymbol came from, we no longer search
3654 all objfiles. In large programs (1000s of shared libs) searching all
3655 objfiles is not worth the pain. */
3657 if (nfiles
== 0 && (kind
== VARIABLES_DOMAIN
|| kind
== FUNCTIONS_DOMAIN
))
3659 ALL_MSYMBOLS (objfile
, msymbol
)
3663 if (msymbol
->created_by_gdb
)
3666 if (MSYMBOL_TYPE (msymbol
) == ourtype
3667 || MSYMBOL_TYPE (msymbol
) == ourtype2
3668 || MSYMBOL_TYPE (msymbol
) == ourtype3
3669 || MSYMBOL_TYPE (msymbol
) == ourtype4
)
3672 || regexec (&datum
.preg
, MSYMBOL_NATURAL_NAME (msymbol
), 0,
3675 /* Note: An important side-effect of these lookup functions
3676 is to expand the symbol table if msymbol is found, for the
3677 benefit of the next loop on ALL_COMPUNITS. */
3678 if (kind
== FUNCTIONS_DOMAIN
3679 ? (find_pc_compunit_symtab
3680 (MSYMBOL_VALUE_ADDRESS (objfile
, msymbol
)) == NULL
)
3681 : (lookup_symbol_in_objfile_from_linkage_name
3682 (objfile
, MSYMBOL_LINKAGE_NAME (msymbol
), VAR_DOMAIN
)
3693 retval_chain
= make_cleanup_free_search_symbols (&found
);
3695 ALL_COMPUNITS (objfile
, cust
)
3697 bv
= COMPUNIT_BLOCKVECTOR (cust
);
3698 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
3700 b
= BLOCKVECTOR_BLOCK (bv
, i
);
3701 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
3703 struct symtab
*real_symtab
= SYMBOL_SYMTAB (sym
);
3707 /* Check first sole REAL_SYMTAB->FILENAME. It does not need to be
3708 a substring of symtab_to_fullname as it may contain "./" etc. */
3709 if ((file_matches (real_symtab
->filename
, files
, nfiles
, 0)
3710 || ((basenames_may_differ
3711 || file_matches (lbasename (real_symtab
->filename
),
3713 && file_matches (symtab_to_fullname (real_symtab
),
3716 || regexec (&datum
.preg
, SYMBOL_NATURAL_NAME (sym
), 0,
3718 && ((kind
== VARIABLES_DOMAIN
3719 && SYMBOL_CLASS (sym
) != LOC_TYPEDEF
3720 && SYMBOL_CLASS (sym
) != LOC_UNRESOLVED
3721 && SYMBOL_CLASS (sym
) != LOC_BLOCK
3722 /* LOC_CONST can be used for more than just enums,
3723 e.g., c++ static const members.
3724 We only want to skip enums here. */
3725 && !(SYMBOL_CLASS (sym
) == LOC_CONST
3726 && (TYPE_CODE (SYMBOL_TYPE (sym
))
3727 == TYPE_CODE_ENUM
)))
3728 || (kind
== FUNCTIONS_DOMAIN
3729 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
3730 || (kind
== TYPES_DOMAIN
3731 && SYMBOL_CLASS (sym
) == LOC_TYPEDEF
))))
3734 struct symbol_search
*psr
= (struct symbol_search
*)
3735 xmalloc (sizeof (struct symbol_search
));
3737 psr
->symtab
= real_symtab
;
3739 memset (&psr
->msymbol
, 0, sizeof (psr
->msymbol
));
3754 sort_search_symbols_remove_dups (found
, nfound
, &found
, &tail
);
3755 /* Note: nfound is no longer useful beyond this point. */
3758 /* If there are no eyes, avoid all contact. I mean, if there are
3759 no debug symbols, then add matching minsyms. */
3761 if (found_misc
|| (nfiles
== 0 && kind
!= FUNCTIONS_DOMAIN
))
3763 ALL_MSYMBOLS (objfile
, msymbol
)
3767 if (msymbol
->created_by_gdb
)
3770 if (MSYMBOL_TYPE (msymbol
) == ourtype
3771 || MSYMBOL_TYPE (msymbol
) == ourtype2
3772 || MSYMBOL_TYPE (msymbol
) == ourtype3
3773 || MSYMBOL_TYPE (msymbol
) == ourtype4
)
3776 || regexec (&datum
.preg
, MSYMBOL_NATURAL_NAME (msymbol
), 0,
3779 /* For functions we can do a quick check of whether the
3780 symbol might be found via find_pc_symtab. */
3781 if (kind
!= FUNCTIONS_DOMAIN
3782 || (find_pc_compunit_symtab
3783 (MSYMBOL_VALUE_ADDRESS (objfile
, msymbol
)) == NULL
))
3785 if (lookup_symbol_in_objfile_from_linkage_name
3786 (objfile
, MSYMBOL_LINKAGE_NAME (msymbol
), VAR_DOMAIN
)
3790 struct symbol_search
*psr
= (struct symbol_search
*)
3791 xmalloc (sizeof (struct symbol_search
));
3793 psr
->msymbol
.minsym
= msymbol
;
3794 psr
->msymbol
.objfile
= objfile
;
3810 discard_cleanups (retval_chain
);
3811 do_cleanups (old_chain
);
3815 /* Helper function for symtab_symbol_info, this function uses
3816 the data returned from search_symbols() to print information
3817 regarding the match to gdb_stdout. */
3820 print_symbol_info (enum search_domain kind
,
3821 struct symtab
*s
, struct symbol
*sym
,
3822 int block
, const char *last
)
3824 const char *s_filename
= symtab_to_filename_for_display (s
);
3826 if (last
== NULL
|| filename_cmp (last
, s_filename
) != 0)
3828 fputs_filtered ("\nFile ", gdb_stdout
);
3829 fputs_filtered (s_filename
, gdb_stdout
);
3830 fputs_filtered (":\n", gdb_stdout
);
3833 if (kind
!= TYPES_DOMAIN
&& block
== STATIC_BLOCK
)
3834 printf_filtered ("static ");
3836 /* Typedef that is not a C++ class. */
3837 if (kind
== TYPES_DOMAIN
3838 && SYMBOL_DOMAIN (sym
) != STRUCT_DOMAIN
)
3839 typedef_print (SYMBOL_TYPE (sym
), sym
, gdb_stdout
);
3840 /* variable, func, or typedef-that-is-c++-class. */
3841 else if (kind
< TYPES_DOMAIN
3842 || (kind
== TYPES_DOMAIN
3843 && SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
))
3845 type_print (SYMBOL_TYPE (sym
),
3846 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
3847 ? "" : SYMBOL_PRINT_NAME (sym
)),
3850 printf_filtered (";\n");
3854 /* This help function for symtab_symbol_info() prints information
3855 for non-debugging symbols to gdb_stdout. */
3858 print_msymbol_info (struct bound_minimal_symbol msymbol
)
3860 struct gdbarch
*gdbarch
= get_objfile_arch (msymbol
.objfile
);
3863 if (gdbarch_addr_bit (gdbarch
) <= 32)
3864 tmp
= hex_string_custom (BMSYMBOL_VALUE_ADDRESS (msymbol
)
3865 & (CORE_ADDR
) 0xffffffff,
3868 tmp
= hex_string_custom (BMSYMBOL_VALUE_ADDRESS (msymbol
),
3870 printf_filtered ("%s %s\n",
3871 tmp
, MSYMBOL_PRINT_NAME (msymbol
.minsym
));
3874 /* This is the guts of the commands "info functions", "info types", and
3875 "info variables". It calls search_symbols to find all matches and then
3876 print_[m]symbol_info to print out some useful information about the
3880 symtab_symbol_info (char *regexp
, enum search_domain kind
, int from_tty
)
3882 static const char * const classnames
[] =
3883 {"variable", "function", "type"};
3884 struct symbol_search
*symbols
;
3885 struct symbol_search
*p
;
3886 struct cleanup
*old_chain
;
3887 const char *last_filename
= NULL
;
3890 gdb_assert (kind
<= TYPES_DOMAIN
);
3892 /* Must make sure that if we're interrupted, symbols gets freed. */
3893 search_symbols (regexp
, kind
, 0, NULL
, &symbols
);
3894 old_chain
= make_cleanup_free_search_symbols (&symbols
);
3897 printf_filtered (_("All %ss matching regular expression \"%s\":\n"),
3898 classnames
[kind
], regexp
);
3900 printf_filtered (_("All defined %ss:\n"), classnames
[kind
]);
3902 for (p
= symbols
; p
!= NULL
; p
= p
->next
)
3906 if (p
->msymbol
.minsym
!= NULL
)
3910 printf_filtered (_("\nNon-debugging symbols:\n"));
3913 print_msymbol_info (p
->msymbol
);
3917 print_symbol_info (kind
,
3922 last_filename
= symtab_to_filename_for_display (p
->symtab
);
3926 do_cleanups (old_chain
);
3930 variables_info (char *regexp
, int from_tty
)
3932 symtab_symbol_info (regexp
, VARIABLES_DOMAIN
, from_tty
);
3936 functions_info (char *regexp
, int from_tty
)
3938 symtab_symbol_info (regexp
, FUNCTIONS_DOMAIN
, from_tty
);
3943 types_info (char *regexp
, int from_tty
)
3945 symtab_symbol_info (regexp
, TYPES_DOMAIN
, from_tty
);
3948 /* Breakpoint all functions matching regular expression. */
3951 rbreak_command_wrapper (char *regexp
, int from_tty
)
3953 rbreak_command (regexp
, from_tty
);
3956 /* A cleanup function that calls end_rbreak_breakpoints. */
3959 do_end_rbreak_breakpoints (void *ignore
)
3961 end_rbreak_breakpoints ();
3965 rbreak_command (char *regexp
, int from_tty
)
3967 struct symbol_search
*ss
;
3968 struct symbol_search
*p
;
3969 struct cleanup
*old_chain
;
3970 char *string
= NULL
;
3972 const char **files
= NULL
;
3973 const char *file_name
;
3978 char *colon
= strchr (regexp
, ':');
3980 if (colon
&& *(colon
+ 1) != ':')
3985 colon_index
= colon
- regexp
;
3986 local_name
= alloca (colon_index
+ 1);
3987 memcpy (local_name
, regexp
, colon_index
);
3988 local_name
[colon_index
--] = 0;
3989 while (isspace (local_name
[colon_index
]))
3990 local_name
[colon_index
--] = 0;
3991 file_name
= local_name
;
3994 regexp
= skip_spaces (colon
+ 1);
3998 search_symbols (regexp
, FUNCTIONS_DOMAIN
, nfiles
, files
, &ss
);
3999 old_chain
= make_cleanup_free_search_symbols (&ss
);
4000 make_cleanup (free_current_contents
, &string
);
4002 start_rbreak_breakpoints ();
4003 make_cleanup (do_end_rbreak_breakpoints
, NULL
);
4004 for (p
= ss
; p
!= NULL
; p
= p
->next
)
4006 if (p
->msymbol
.minsym
== NULL
)
4008 const char *fullname
= symtab_to_fullname (p
->symtab
);
4010 int newlen
= (strlen (fullname
)
4011 + strlen (SYMBOL_LINKAGE_NAME (p
->symbol
))
4016 string
= xrealloc (string
, newlen
);
4019 strcpy (string
, fullname
);
4020 strcat (string
, ":'");
4021 strcat (string
, SYMBOL_LINKAGE_NAME (p
->symbol
));
4022 strcat (string
, "'");
4023 break_command (string
, from_tty
);
4024 print_symbol_info (FUNCTIONS_DOMAIN
,
4028 symtab_to_filename_for_display (p
->symtab
));
4032 int newlen
= (strlen (MSYMBOL_LINKAGE_NAME (p
->msymbol
.minsym
)) + 3);
4036 string
= xrealloc (string
, newlen
);
4039 strcpy (string
, "'");
4040 strcat (string
, MSYMBOL_LINKAGE_NAME (p
->msymbol
.minsym
));
4041 strcat (string
, "'");
4043 break_command (string
, from_tty
);
4044 printf_filtered ("<function, no debug info> %s;\n",
4045 MSYMBOL_PRINT_NAME (p
->msymbol
.minsym
));
4049 do_cleanups (old_chain
);
4053 /* Evaluate if NAME matches SYM_TEXT and SYM_TEXT_LEN.
4055 Either sym_text[sym_text_len] != '(' and then we search for any
4056 symbol starting with SYM_TEXT text.
4058 Otherwise sym_text[sym_text_len] == '(' and then we require symbol name to
4059 be terminated at that point. Partial symbol tables do not have parameters
4063 compare_symbol_name (const char *name
, const char *sym_text
, int sym_text_len
)
4065 int (*ncmp
) (const char *, const char *, size_t);
4067 ncmp
= (case_sensitivity
== case_sensitive_on
? strncmp
: strncasecmp
);
4069 if (ncmp (name
, sym_text
, sym_text_len
) != 0)
4072 if (sym_text
[sym_text_len
] == '(')
4074 /* User searches for `name(someth...'. Require NAME to be terminated.
4075 Normally psymtabs and gdbindex have no parameter types so '\0' will be
4076 present but accept even parameters presence. In this case this
4077 function is in fact strcmp_iw but whitespace skipping is not supported
4078 for tab completion. */
4080 if (name
[sym_text_len
] != '\0' && name
[sym_text_len
] != '(')
4087 /* Free any memory associated with a completion list. */
4090 free_completion_list (VEC (char_ptr
) **list_ptr
)
4095 for (i
= 0; VEC_iterate (char_ptr
, *list_ptr
, i
, p
); ++i
)
4097 VEC_free (char_ptr
, *list_ptr
);
4100 /* Callback for make_cleanup. */
4103 do_free_completion_list (void *list
)
4105 free_completion_list (list
);
4108 /* Helper routine for make_symbol_completion_list. */
4110 static VEC (char_ptr
) *return_val
;
4112 #define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
4113 completion_list_add_name \
4114 (SYMBOL_NATURAL_NAME (symbol), (sym_text), (len), (text), (word))
4116 #define MCOMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
4117 completion_list_add_name \
4118 (MSYMBOL_NATURAL_NAME (symbol), (sym_text), (len), (text), (word))
4120 /* Test to see if the symbol specified by SYMNAME (which is already
4121 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
4122 characters. If so, add it to the current completion list. */
4125 completion_list_add_name (const char *symname
,
4126 const char *sym_text
, int sym_text_len
,
4127 const char *text
, const char *word
)
4129 /* Clip symbols that cannot match. */
4130 if (!compare_symbol_name (symname
, sym_text
, sym_text_len
))
4133 /* We have a match for a completion, so add SYMNAME to the current list
4134 of matches. Note that the name is moved to freshly malloc'd space. */
4139 if (word
== sym_text
)
4141 new = xmalloc (strlen (symname
) + 5);
4142 strcpy (new, symname
);
4144 else if (word
> sym_text
)
4146 /* Return some portion of symname. */
4147 new = xmalloc (strlen (symname
) + 5);
4148 strcpy (new, symname
+ (word
- sym_text
));
4152 /* Return some of SYM_TEXT plus symname. */
4153 new = xmalloc (strlen (symname
) + (sym_text
- word
) + 5);
4154 strncpy (new, word
, sym_text
- word
);
4155 new[sym_text
- word
] = '\0';
4156 strcat (new, symname
);
4159 VEC_safe_push (char_ptr
, return_val
, new);
4163 /* ObjC: In case we are completing on a selector, look as the msymbol
4164 again and feed all the selectors into the mill. */
4167 completion_list_objc_symbol (struct minimal_symbol
*msymbol
,
4168 const char *sym_text
, int sym_text_len
,
4169 const char *text
, const char *word
)
4171 static char *tmp
= NULL
;
4172 static unsigned int tmplen
= 0;
4174 const char *method
, *category
, *selector
;
4177 method
= MSYMBOL_NATURAL_NAME (msymbol
);
4179 /* Is it a method? */
4180 if ((method
[0] != '-') && (method
[0] != '+'))
4183 if (sym_text
[0] == '[')
4184 /* Complete on shortened method method. */
4185 completion_list_add_name (method
+ 1, sym_text
, sym_text_len
, text
, word
);
4187 while ((strlen (method
) + 1) >= tmplen
)
4193 tmp
= xrealloc (tmp
, tmplen
);
4195 selector
= strchr (method
, ' ');
4196 if (selector
!= NULL
)
4199 category
= strchr (method
, '(');
4201 if ((category
!= NULL
) && (selector
!= NULL
))
4203 memcpy (tmp
, method
, (category
- method
));
4204 tmp
[category
- method
] = ' ';
4205 memcpy (tmp
+ (category
- method
) + 1, selector
, strlen (selector
) + 1);
4206 completion_list_add_name (tmp
, sym_text
, sym_text_len
, text
, word
);
4207 if (sym_text
[0] == '[')
4208 completion_list_add_name (tmp
+ 1, sym_text
, sym_text_len
, text
, word
);
4211 if (selector
!= NULL
)
4213 /* Complete on selector only. */
4214 strcpy (tmp
, selector
);
4215 tmp2
= strchr (tmp
, ']');
4219 completion_list_add_name (tmp
, sym_text
, sym_text_len
, text
, word
);
4223 /* Break the non-quoted text based on the characters which are in
4224 symbols. FIXME: This should probably be language-specific. */
4227 language_search_unquoted_string (const char *text
, const char *p
)
4229 for (; p
> text
; --p
)
4231 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
4235 if ((current_language
->la_language
== language_objc
))
4237 if (p
[-1] == ':') /* Might be part of a method name. */
4239 else if (p
[-1] == '[' && (p
[-2] == '-' || p
[-2] == '+'))
4240 p
-= 2; /* Beginning of a method name. */
4241 else if (p
[-1] == ' ' || p
[-1] == '(' || p
[-1] == ')')
4242 { /* Might be part of a method name. */
4245 /* Seeing a ' ' or a '(' is not conclusive evidence
4246 that we are in the middle of a method name. However,
4247 finding "-[" or "+[" should be pretty un-ambiguous.
4248 Unfortunately we have to find it now to decide. */
4251 if (isalnum (t
[-1]) || t
[-1] == '_' ||
4252 t
[-1] == ' ' || t
[-1] == ':' ||
4253 t
[-1] == '(' || t
[-1] == ')')
4258 if (t
[-1] == '[' && (t
[-2] == '-' || t
[-2] == '+'))
4259 p
= t
- 2; /* Method name detected. */
4260 /* Else we leave with p unchanged. */
4270 completion_list_add_fields (struct symbol
*sym
, const char *sym_text
,
4271 int sym_text_len
, const char *text
,
4274 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
4276 struct type
*t
= SYMBOL_TYPE (sym
);
4277 enum type_code c
= TYPE_CODE (t
);
4280 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
4281 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
4282 if (TYPE_FIELD_NAME (t
, j
))
4283 completion_list_add_name (TYPE_FIELD_NAME (t
, j
),
4284 sym_text
, sym_text_len
, text
, word
);
4288 /* Type of the user_data argument passed to add_macro_name or
4289 symbol_completion_matcher. The contents are simply whatever is
4290 needed by completion_list_add_name. */
4291 struct add_name_data
4293 const char *sym_text
;
4299 /* A callback used with macro_for_each and macro_for_each_in_scope.
4300 This adds a macro's name to the current completion list. */
4303 add_macro_name (const char *name
, const struct macro_definition
*ignore
,
4304 struct macro_source_file
*ignore2
, int ignore3
,
4307 struct add_name_data
*datum
= (struct add_name_data
*) user_data
;
4309 completion_list_add_name (name
,
4310 datum
->sym_text
, datum
->sym_text_len
,
4311 datum
->text
, datum
->word
);
4314 /* A callback for expand_symtabs_matching. */
4317 symbol_completion_matcher (const char *name
, void *user_data
)
4319 struct add_name_data
*datum
= (struct add_name_data
*) user_data
;
4321 return compare_symbol_name (name
, datum
->sym_text
, datum
->sym_text_len
);
4325 default_make_symbol_completion_list_break_on (const char *text
,
4327 const char *break_on
,
4328 enum type_code code
)
4330 /* Problem: All of the symbols have to be copied because readline
4331 frees them. I'm not going to worry about this; hopefully there
4332 won't be that many. */
4335 struct compunit_symtab
*cust
;
4336 struct minimal_symbol
*msymbol
;
4337 struct objfile
*objfile
;
4338 const struct block
*b
;
4339 const struct block
*surrounding_static_block
, *surrounding_global_block
;
4340 struct block_iterator iter
;
4341 /* The symbol we are completing on. Points in same buffer as text. */
4342 const char *sym_text
;
4343 /* Length of sym_text. */
4345 struct add_name_data datum
;
4346 struct cleanup
*back_to
;
4348 /* Now look for the symbol we are supposed to complete on. */
4352 const char *quote_pos
= NULL
;
4354 /* First see if this is a quoted string. */
4356 for (p
= text
; *p
!= '\0'; ++p
)
4358 if (quote_found
!= '\0')
4360 if (*p
== quote_found
)
4361 /* Found close quote. */
4363 else if (*p
== '\\' && p
[1] == quote_found
)
4364 /* A backslash followed by the quote character
4365 doesn't end the string. */
4368 else if (*p
== '\'' || *p
== '"')
4374 if (quote_found
== '\'')
4375 /* A string within single quotes can be a symbol, so complete on it. */
4376 sym_text
= quote_pos
+ 1;
4377 else if (quote_found
== '"')
4378 /* A double-quoted string is never a symbol, nor does it make sense
4379 to complete it any other way. */
4385 /* It is not a quoted string. Break it based on the characters
4386 which are in symbols. */
4389 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0'
4390 || p
[-1] == ':' || strchr (break_on
, p
[-1]) != NULL
)
4399 sym_text_len
= strlen (sym_text
);
4401 /* Prepare SYM_TEXT_LEN for compare_symbol_name. */
4403 if (current_language
->la_language
== language_cplus
4404 || current_language
->la_language
== language_java
4405 || current_language
->la_language
== language_fortran
)
4407 /* These languages may have parameters entered by user but they are never
4408 present in the partial symbol tables. */
4410 const char *cs
= memchr (sym_text
, '(', sym_text_len
);
4413 sym_text_len
= cs
- sym_text
;
4415 gdb_assert (sym_text
[sym_text_len
] == '\0' || sym_text
[sym_text_len
] == '(');
4418 back_to
= make_cleanup (do_free_completion_list
, &return_val
);
4420 datum
.sym_text
= sym_text
;
4421 datum
.sym_text_len
= sym_text_len
;
4425 /* Look through the partial symtabs for all symbols which begin
4426 by matching SYM_TEXT. Expand all CUs that you find to the list.
4427 The real names will get added by COMPLETION_LIST_ADD_SYMBOL below. */
4428 expand_symtabs_matching (NULL
, symbol_completion_matcher
, ALL_DOMAIN
,
4431 /* At this point scan through the misc symbol vectors and add each
4432 symbol you find to the list. Eventually we want to ignore
4433 anything that isn't a text symbol (everything else will be
4434 handled by the psymtab code above). */
4436 if (code
== TYPE_CODE_UNDEF
)
4438 ALL_MSYMBOLS (objfile
, msymbol
)
4441 MCOMPLETION_LIST_ADD_SYMBOL (msymbol
, sym_text
, sym_text_len
, text
,
4444 completion_list_objc_symbol (msymbol
, sym_text
, sym_text_len
, text
,
4449 /* Search upwards from currently selected frame (so that we can
4450 complete on local vars). Also catch fields of types defined in
4451 this places which match our text string. Only complete on types
4452 visible from current context. */
4454 b
= get_selected_block (0);
4455 surrounding_static_block
= block_static_block (b
);
4456 surrounding_global_block
= block_global_block (b
);
4457 if (surrounding_static_block
!= NULL
)
4458 while (b
!= surrounding_static_block
)
4462 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
4464 if (code
== TYPE_CODE_UNDEF
)
4466 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
,
4468 completion_list_add_fields (sym
, sym_text
, sym_text_len
, text
,
4471 else if (SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
4472 && TYPE_CODE (SYMBOL_TYPE (sym
)) == code
)
4473 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
,
4477 /* Stop when we encounter an enclosing function. Do not stop for
4478 non-inlined functions - the locals of the enclosing function
4479 are in scope for a nested function. */
4480 if (BLOCK_FUNCTION (b
) != NULL
&& block_inlined_p (b
))
4482 b
= BLOCK_SUPERBLOCK (b
);
4485 /* Add fields from the file's types; symbols will be added below. */
4487 if (code
== TYPE_CODE_UNDEF
)
4489 if (surrounding_static_block
!= NULL
)
4490 ALL_BLOCK_SYMBOLS (surrounding_static_block
, iter
, sym
)
4491 completion_list_add_fields (sym
, sym_text
, sym_text_len
, text
, word
);
4493 if (surrounding_global_block
!= NULL
)
4494 ALL_BLOCK_SYMBOLS (surrounding_global_block
, iter
, sym
)
4495 completion_list_add_fields (sym
, sym_text
, sym_text_len
, text
, word
);
4498 /* Go through the symtabs and check the externs and statics for
4499 symbols which match. */
4501 ALL_COMPUNITS (objfile
, cust
)
4504 b
= BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
), GLOBAL_BLOCK
);
4505 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
4507 if (code
== TYPE_CODE_UNDEF
4508 || (SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
4509 && TYPE_CODE (SYMBOL_TYPE (sym
)) == code
))
4510 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
4514 ALL_COMPUNITS (objfile
, cust
)
4517 b
= BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
), STATIC_BLOCK
);
4518 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
4520 if (code
== TYPE_CODE_UNDEF
4521 || (SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
4522 && TYPE_CODE (SYMBOL_TYPE (sym
)) == code
))
4523 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
4527 /* Skip macros if we are completing a struct tag -- arguable but
4528 usually what is expected. */
4529 if (current_language
->la_macro_expansion
== macro_expansion_c
4530 && code
== TYPE_CODE_UNDEF
)
4532 struct macro_scope
*scope
;
4534 /* Add any macros visible in the default scope. Note that this
4535 may yield the occasional wrong result, because an expression
4536 might be evaluated in a scope other than the default. For
4537 example, if the user types "break file:line if <TAB>", the
4538 resulting expression will be evaluated at "file:line" -- but
4539 at there does not seem to be a way to detect this at
4541 scope
= default_macro_scope ();
4544 macro_for_each_in_scope (scope
->file
, scope
->line
,
4545 add_macro_name
, &datum
);
4549 /* User-defined macros are always visible. */
4550 macro_for_each (macro_user_macros
, add_macro_name
, &datum
);
4553 discard_cleanups (back_to
);
4554 return (return_val
);
4558 default_make_symbol_completion_list (const char *text
, const char *word
,
4559 enum type_code code
)
4561 return default_make_symbol_completion_list_break_on (text
, word
, "", code
);
4564 /* Return a vector of all symbols (regardless of class) which begin by
4565 matching TEXT. If the answer is no symbols, then the return value
4569 make_symbol_completion_list (const char *text
, const char *word
)
4571 return current_language
->la_make_symbol_completion_list (text
, word
,
4575 /* Like make_symbol_completion_list, but only return STRUCT_DOMAIN
4576 symbols whose type code is CODE. */
4579 make_symbol_completion_type (const char *text
, const char *word
,
4580 enum type_code code
)
4582 gdb_assert (code
== TYPE_CODE_UNION
4583 || code
== TYPE_CODE_STRUCT
4584 || code
== TYPE_CODE_ENUM
);
4585 return current_language
->la_make_symbol_completion_list (text
, word
, code
);
4588 /* Like make_symbol_completion_list, but suitable for use as a
4589 completion function. */
4592 make_symbol_completion_list_fn (struct cmd_list_element
*ignore
,
4593 const char *text
, const char *word
)
4595 return make_symbol_completion_list (text
, word
);
4598 /* Like make_symbol_completion_list, but returns a list of symbols
4599 defined in a source file FILE. */
4602 make_file_symbol_completion_list (const char *text
, const char *word
,
4603 const char *srcfile
)
4608 struct block_iterator iter
;
4609 /* The symbol we are completing on. Points in same buffer as text. */
4610 const char *sym_text
;
4611 /* Length of sym_text. */
4614 /* Now look for the symbol we are supposed to complete on.
4615 FIXME: This should be language-specific. */
4619 const char *quote_pos
= NULL
;
4621 /* First see if this is a quoted string. */
4623 for (p
= text
; *p
!= '\0'; ++p
)
4625 if (quote_found
!= '\0')
4627 if (*p
== quote_found
)
4628 /* Found close quote. */
4630 else if (*p
== '\\' && p
[1] == quote_found
)
4631 /* A backslash followed by the quote character
4632 doesn't end the string. */
4635 else if (*p
== '\'' || *p
== '"')
4641 if (quote_found
== '\'')
4642 /* A string within single quotes can be a symbol, so complete on it. */
4643 sym_text
= quote_pos
+ 1;
4644 else if (quote_found
== '"')
4645 /* A double-quoted string is never a symbol, nor does it make sense
4646 to complete it any other way. */
4652 /* Not a quoted string. */
4653 sym_text
= language_search_unquoted_string (text
, p
);
4657 sym_text_len
= strlen (sym_text
);
4661 /* Find the symtab for SRCFILE (this loads it if it was not yet read
4663 s
= lookup_symtab (srcfile
);
4666 /* Maybe they typed the file with leading directories, while the
4667 symbol tables record only its basename. */
4668 const char *tail
= lbasename (srcfile
);
4671 s
= lookup_symtab (tail
);
4674 /* If we have no symtab for that file, return an empty list. */
4676 return (return_val
);
4678 /* Go through this symtab and check the externs and statics for
4679 symbols which match. */
4681 b
= BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (s
), GLOBAL_BLOCK
);
4682 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
4684 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
4687 b
= BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (s
), STATIC_BLOCK
);
4688 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
4690 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
4693 return (return_val
);
4696 /* A helper function for make_source_files_completion_list. It adds
4697 another file name to a list of possible completions, growing the
4698 list as necessary. */
4701 add_filename_to_list (const char *fname
, const char *text
, const char *word
,
4702 VEC (char_ptr
) **list
)
4705 size_t fnlen
= strlen (fname
);
4709 /* Return exactly fname. */
4710 new = xmalloc (fnlen
+ 5);
4711 strcpy (new, fname
);
4713 else if (word
> text
)
4715 /* Return some portion of fname. */
4716 new = xmalloc (fnlen
+ 5);
4717 strcpy (new, fname
+ (word
- text
));
4721 /* Return some of TEXT plus fname. */
4722 new = xmalloc (fnlen
+ (text
- word
) + 5);
4723 strncpy (new, word
, text
- word
);
4724 new[text
- word
] = '\0';
4725 strcat (new, fname
);
4727 VEC_safe_push (char_ptr
, *list
, new);
4731 not_interesting_fname (const char *fname
)
4733 static const char *illegal_aliens
[] = {
4734 "_globals_", /* inserted by coff_symtab_read */
4739 for (i
= 0; illegal_aliens
[i
]; i
++)
4741 if (filename_cmp (fname
, illegal_aliens
[i
]) == 0)
4747 /* An object of this type is passed as the user_data argument to
4748 map_partial_symbol_filenames. */
4749 struct add_partial_filename_data
4751 struct filename_seen_cache
*filename_seen_cache
;
4755 VEC (char_ptr
) **list
;
4758 /* A callback for map_partial_symbol_filenames. */
4761 maybe_add_partial_symtab_filename (const char *filename
, const char *fullname
,
4764 struct add_partial_filename_data
*data
= user_data
;
4766 if (not_interesting_fname (filename
))
4768 if (!filename_seen (data
->filename_seen_cache
, filename
, 1)
4769 && filename_ncmp (filename
, data
->text
, data
->text_len
) == 0)
4771 /* This file matches for a completion; add it to the
4772 current list of matches. */
4773 add_filename_to_list (filename
, data
->text
, data
->word
, data
->list
);
4777 const char *base_name
= lbasename (filename
);
4779 if (base_name
!= filename
4780 && !filename_seen (data
->filename_seen_cache
, base_name
, 1)
4781 && filename_ncmp (base_name
, data
->text
, data
->text_len
) == 0)
4782 add_filename_to_list (base_name
, data
->text
, data
->word
, data
->list
);
4786 /* Return a vector of all source files whose names begin with matching
4787 TEXT. The file names are looked up in the symbol tables of this
4788 program. If the answer is no matchess, then the return value is
4792 make_source_files_completion_list (const char *text
, const char *word
)
4794 struct compunit_symtab
*cu
;
4796 struct objfile
*objfile
;
4797 size_t text_len
= strlen (text
);
4798 VEC (char_ptr
) *list
= NULL
;
4799 const char *base_name
;
4800 struct add_partial_filename_data datum
;
4801 struct filename_seen_cache
*filename_seen_cache
;
4802 struct cleanup
*back_to
, *cache_cleanup
;
4804 if (!have_full_symbols () && !have_partial_symbols ())
4807 back_to
= make_cleanup (do_free_completion_list
, &list
);
4809 filename_seen_cache
= create_filename_seen_cache ();
4810 cache_cleanup
= make_cleanup (delete_filename_seen_cache
,
4811 filename_seen_cache
);
4813 ALL_FILETABS (objfile
, cu
, s
)
4815 if (not_interesting_fname (s
->filename
))
4817 if (!filename_seen (filename_seen_cache
, s
->filename
, 1)
4818 && filename_ncmp (s
->filename
, text
, text_len
) == 0)
4820 /* This file matches for a completion; add it to the current
4822 add_filename_to_list (s
->filename
, text
, word
, &list
);
4826 /* NOTE: We allow the user to type a base name when the
4827 debug info records leading directories, but not the other
4828 way around. This is what subroutines of breakpoint
4829 command do when they parse file names. */
4830 base_name
= lbasename (s
->filename
);
4831 if (base_name
!= s
->filename
4832 && !filename_seen (filename_seen_cache
, base_name
, 1)
4833 && filename_ncmp (base_name
, text
, text_len
) == 0)
4834 add_filename_to_list (base_name
, text
, word
, &list
);
4838 datum
.filename_seen_cache
= filename_seen_cache
;
4841 datum
.text_len
= text_len
;
4843 map_symbol_filenames (maybe_add_partial_symtab_filename
, &datum
,
4844 0 /*need_fullname*/);
4846 do_cleanups (cache_cleanup
);
4847 discard_cleanups (back_to
);
4854 /* Return the "main_info" object for the current program space. If
4855 the object has not yet been created, create it and fill in some
4858 static struct main_info
*
4859 get_main_info (void)
4861 struct main_info
*info
= program_space_data (current_program_space
,
4862 main_progspace_key
);
4866 /* It may seem strange to store the main name in the progspace
4867 and also in whatever objfile happens to see a main name in
4868 its debug info. The reason for this is mainly historical:
4869 gdb returned "main" as the name even if no function named
4870 "main" was defined the program; and this approach lets us
4871 keep compatibility. */
4872 info
= XCNEW (struct main_info
);
4873 info
->language_of_main
= language_unknown
;
4874 set_program_space_data (current_program_space
, main_progspace_key
,
4881 /* A cleanup to destroy a struct main_info when a progspace is
4885 main_info_cleanup (struct program_space
*pspace
, void *data
)
4887 struct main_info
*info
= data
;
4890 xfree (info
->name_of_main
);
4895 set_main_name (const char *name
, enum language lang
)
4897 struct main_info
*info
= get_main_info ();
4899 if (info
->name_of_main
!= NULL
)
4901 xfree (info
->name_of_main
);
4902 info
->name_of_main
= NULL
;
4903 info
->language_of_main
= language_unknown
;
4907 info
->name_of_main
= xstrdup (name
);
4908 info
->language_of_main
= lang
;
4912 /* Deduce the name of the main procedure, and set NAME_OF_MAIN
4916 find_main_name (void)
4918 const char *new_main_name
;
4919 struct objfile
*objfile
;
4921 /* First check the objfiles to see whether a debuginfo reader has
4922 picked up the appropriate main name. Historically the main name
4923 was found in a more or less random way; this approach instead
4924 relies on the order of objfile creation -- which still isn't
4925 guaranteed to get the correct answer, but is just probably more
4927 ALL_OBJFILES (objfile
)
4929 if (objfile
->per_bfd
->name_of_main
!= NULL
)
4931 set_main_name (objfile
->per_bfd
->name_of_main
,
4932 objfile
->per_bfd
->language_of_main
);
4937 /* Try to see if the main procedure is in Ada. */
4938 /* FIXME: brobecker/2005-03-07: Another way of doing this would
4939 be to add a new method in the language vector, and call this
4940 method for each language until one of them returns a non-empty
4941 name. This would allow us to remove this hard-coded call to
4942 an Ada function. It is not clear that this is a better approach
4943 at this point, because all methods need to be written in a way
4944 such that false positives never be returned. For instance, it is
4945 important that a method does not return a wrong name for the main
4946 procedure if the main procedure is actually written in a different
4947 language. It is easy to guaranty this with Ada, since we use a
4948 special symbol generated only when the main in Ada to find the name
4949 of the main procedure. It is difficult however to see how this can
4950 be guarantied for languages such as C, for instance. This suggests
4951 that order of call for these methods becomes important, which means
4952 a more complicated approach. */
4953 new_main_name
= ada_main_name ();
4954 if (new_main_name
!= NULL
)
4956 set_main_name (new_main_name
, language_ada
);
4960 new_main_name
= d_main_name ();
4961 if (new_main_name
!= NULL
)
4963 set_main_name (new_main_name
, language_d
);
4967 new_main_name
= go_main_name ();
4968 if (new_main_name
!= NULL
)
4970 set_main_name (new_main_name
, language_go
);
4974 new_main_name
= pascal_main_name ();
4975 if (new_main_name
!= NULL
)
4977 set_main_name (new_main_name
, language_pascal
);
4981 /* The languages above didn't identify the name of the main procedure.
4982 Fallback to "main". */
4983 set_main_name ("main", language_unknown
);
4989 struct main_info
*info
= get_main_info ();
4991 if (info
->name_of_main
== NULL
)
4994 return info
->name_of_main
;
4997 /* Return the language of the main function. If it is not known,
4998 return language_unknown. */
5001 main_language (void)
5003 struct main_info
*info
= get_main_info ();
5005 if (info
->name_of_main
== NULL
)
5008 return info
->language_of_main
;
5011 /* Handle ``executable_changed'' events for the symtab module. */
5014 symtab_observer_executable_changed (void)
5016 /* NAME_OF_MAIN may no longer be the same, so reset it for now. */
5017 set_main_name (NULL
, language_unknown
);
5020 /* Return 1 if the supplied producer string matches the ARM RealView
5021 compiler (armcc). */
5024 producer_is_realview (const char *producer
)
5026 static const char *const arm_idents
[] = {
5027 "ARM C Compiler, ADS",
5028 "Thumb C Compiler, ADS",
5029 "ARM C++ Compiler, ADS",
5030 "Thumb C++ Compiler, ADS",
5031 "ARM/Thumb C/C++ Compiler, RVCT",
5032 "ARM C/C++ Compiler, RVCT"
5036 if (producer
== NULL
)
5039 for (i
= 0; i
< ARRAY_SIZE (arm_idents
); i
++)
5040 if (strncmp (producer
, arm_idents
[i
], strlen (arm_idents
[i
])) == 0)
5048 /* The next index to hand out in response to a registration request. */
5050 static int next_aclass_value
= LOC_FINAL_VALUE
;
5052 /* The maximum number of "aclass" registrations we support. This is
5053 constant for convenience. */
5054 #define MAX_SYMBOL_IMPLS (LOC_FINAL_VALUE + 10)
5056 /* The objects representing the various "aclass" values. The elements
5057 from 0 up to LOC_FINAL_VALUE-1 represent themselves, and subsequent
5058 elements are those registered at gdb initialization time. */
5060 static struct symbol_impl symbol_impl
[MAX_SYMBOL_IMPLS
];
5062 /* The globally visible pointer. This is separate from 'symbol_impl'
5063 so that it can be const. */
5065 const struct symbol_impl
*symbol_impls
= &symbol_impl
[0];
5067 /* Make sure we saved enough room in struct symbol. */
5069 gdb_static_assert (MAX_SYMBOL_IMPLS
<= (1 << SYMBOL_ACLASS_BITS
));
5071 /* Register a computed symbol type. ACLASS must be LOC_COMPUTED. OPS
5072 is the ops vector associated with this index. This returns the new
5073 index, which should be used as the aclass_index field for symbols
5077 register_symbol_computed_impl (enum address_class aclass
,
5078 const struct symbol_computed_ops
*ops
)
5080 int result
= next_aclass_value
++;
5082 gdb_assert (aclass
== LOC_COMPUTED
);
5083 gdb_assert (result
< MAX_SYMBOL_IMPLS
);
5084 symbol_impl
[result
].aclass
= aclass
;
5085 symbol_impl
[result
].ops_computed
= ops
;
5087 /* Sanity check OPS. */
5088 gdb_assert (ops
!= NULL
);
5089 gdb_assert (ops
->tracepoint_var_ref
!= NULL
);
5090 gdb_assert (ops
->describe_location
!= NULL
);
5091 gdb_assert (ops
->read_needs_frame
!= NULL
);
5092 gdb_assert (ops
->read_variable
!= NULL
);
5097 /* Register a function with frame base type. ACLASS must be LOC_BLOCK.
5098 OPS is the ops vector associated with this index. This returns the
5099 new index, which should be used as the aclass_index field for symbols
5103 register_symbol_block_impl (enum address_class aclass
,
5104 const struct symbol_block_ops
*ops
)
5106 int result
= next_aclass_value
++;
5108 gdb_assert (aclass
== LOC_BLOCK
);
5109 gdb_assert (result
< MAX_SYMBOL_IMPLS
);
5110 symbol_impl
[result
].aclass
= aclass
;
5111 symbol_impl
[result
].ops_block
= ops
;
5113 /* Sanity check OPS. */
5114 gdb_assert (ops
!= NULL
);
5115 gdb_assert (ops
->find_frame_base_location
!= NULL
);
5120 /* Register a register symbol type. ACLASS must be LOC_REGISTER or
5121 LOC_REGPARM_ADDR. OPS is the register ops vector associated with
5122 this index. This returns the new index, which should be used as
5123 the aclass_index field for symbols of this type. */
5126 register_symbol_register_impl (enum address_class aclass
,
5127 const struct symbol_register_ops
*ops
)
5129 int result
= next_aclass_value
++;
5131 gdb_assert (aclass
== LOC_REGISTER
|| aclass
== LOC_REGPARM_ADDR
);
5132 gdb_assert (result
< MAX_SYMBOL_IMPLS
);
5133 symbol_impl
[result
].aclass
= aclass
;
5134 symbol_impl
[result
].ops_register
= ops
;
5139 /* Initialize elements of 'symbol_impl' for the constants in enum
5143 initialize_ordinary_address_classes (void)
5147 for (i
= 0; i
< LOC_FINAL_VALUE
; ++i
)
5148 symbol_impl
[i
].aclass
= i
;
5153 /* Initialize the symbol SYM. */
5156 initialize_symbol (struct symbol
*sym
)
5158 memset (sym
, 0, sizeof (*sym
));
5159 SYMBOL_SECTION (sym
) = -1;
5162 /* Allocate and initialize a new 'struct symbol' on OBJFILE's
5166 allocate_symbol (struct objfile
*objfile
)
5168 struct symbol
*result
;
5170 result
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct symbol
);
5171 SYMBOL_SECTION (result
) = -1;
5176 /* Allocate and initialize a new 'struct template_symbol' on OBJFILE's
5179 struct template_symbol
*
5180 allocate_template_symbol (struct objfile
*objfile
)
5182 struct template_symbol
*result
;
5184 result
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct template_symbol
);
5185 SYMBOL_SECTION (&result
->base
) = -1;
5193 _initialize_symtab (void)
5195 initialize_ordinary_address_classes ();
5198 = register_program_space_data_with_cleanup (NULL
, main_info_cleanup
);
5200 add_info ("variables", variables_info
, _("\
5201 All global and static variable names, or those matching REGEXP."));
5203 add_com ("whereis", class_info
, variables_info
, _("\
5204 All global and static variable names, or those matching REGEXP."));
5206 add_info ("functions", functions_info
,
5207 _("All function names, or those matching REGEXP."));
5209 /* FIXME: This command has at least the following problems:
5210 1. It prints builtin types (in a very strange and confusing fashion).
5211 2. It doesn't print right, e.g. with
5212 typedef struct foo *FOO
5213 type_print prints "FOO" when we want to make it (in this situation)
5214 print "struct foo *".
5215 I also think "ptype" or "whatis" is more likely to be useful (but if
5216 there is much disagreement "info types" can be fixed). */
5217 add_info ("types", types_info
,
5218 _("All type names, or those matching REGEXP."));
5220 add_info ("sources", sources_info
,
5221 _("Source files in the program."));
5223 add_com ("rbreak", class_breakpoint
, rbreak_command
,
5224 _("Set a breakpoint for all functions matching REGEXP."));
5228 add_com ("lf", class_info
, sources_info
,
5229 _("Source files in the program"));
5230 add_com ("lg", class_info
, variables_info
, _("\
5231 All global and static variable names, or those matching REGEXP."));
5234 add_setshow_enum_cmd ("multiple-symbols", no_class
,
5235 multiple_symbols_modes
, &multiple_symbols_mode
,
5237 Set the debugger behavior when more than one symbol are possible matches\n\
5238 in an expression."), _("\
5239 Show how the debugger handles ambiguities in expressions."), _("\
5240 Valid values are \"ask\", \"all\", \"cancel\", and the default is \"all\"."),
5241 NULL
, NULL
, &setlist
, &showlist
);
5243 add_setshow_boolean_cmd ("basenames-may-differ", class_obscure
,
5244 &basenames_may_differ
, _("\
5245 Set whether a source file may have multiple base names."), _("\
5246 Show whether a source file may have multiple base names."), _("\
5247 (A \"base name\" is the name of a file with the directory part removed.\n\
5248 Example: The base name of \"/home/user/hello.c\" is \"hello.c\".)\n\
5249 If set, GDB will canonicalize file names (e.g., expand symlinks)\n\
5250 before comparing them. Canonicalization is an expensive operation,\n\
5251 but it allows the same file be known by more than one base name.\n\
5252 If not set (the default), all source files are assumed to have just\n\
5253 one base name, and gdb will do file name comparisons more efficiently."),
5255 &setlist
, &showlist
);
5257 add_setshow_zuinteger_cmd ("symtab-create", no_class
, &symtab_create_debug
,
5258 _("Set debugging of symbol table creation."),
5259 _("Show debugging of symbol table creation."), _("\
5260 When enabled (non-zero), debugging messages are printed when building\n\
5261 symbol tables. A value of 1 (one) normally provides enough information.\n\
5262 A value greater than 1 provides more verbose information."),
5265 &setdebuglist
, &showdebuglist
);
5267 observer_attach_executable_changed (symtab_observer_executable_changed
);