1/* Symbol table lookup for the GNU debugger, GDB. 2 3 Copyright (C) 1986-2023 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 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. 11 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. 16 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/>. */ 19 20#include "defs.h" 21#include "symtab.h" 22#include "gdbtypes.h" 23#include "gdbcore.h" 24#include "frame.h" 25#include "target.h" 26#include "value.h" 27#include "symfile.h" 28#include "objfiles.h" 29#include "gdbcmd.h" 30#include "gdbsupport/gdb_regex.h" 31#include "expression.h" 32#include "language.h" 33#include "demangle.h" 34#include "inferior.h" 35#include "source.h" 36#include "filenames.h" /* for FILENAME_CMP */ 37#include "objc-lang.h" 38#include "d-lang.h" 39#include "ada-lang.h" 40#include "go-lang.h" 41#include "p-lang.h" 42#include "addrmap.h" 43#include "cli/cli-utils.h" 44#include "cli/cli-style.h" 45#include "cli/cli-cmds.h" 46#include "fnmatch.h" 47#include "hashtab.h" 48#include "typeprint.h" 49 50#include "gdbsupport/gdb_obstack.h" 51#include "block.h" 52#include "dictionary.h" 53 54#include <sys/types.h> 55#include <fcntl.h> 56#include <sys/stat.h> 57#include <ctype.h> 58#include "cp-abi.h" 59#include "cp-support.h" 60#include "observable.h" 61#include "solist.h" 62#include "macrotab.h" 63#include "macroscope.h" 64 65#include "parser-defs.h" 66#include "completer.h" 67#include "progspace-and-thread.h" 68#include "gdbsupport/gdb_optional.h" 69#include "filename-seen-cache.h" 70#include "arch-utils.h" 71#include <algorithm> 72#include "gdbsupport/gdb_string_view.h" 73#include "gdbsupport/pathstuff.h" 74#include "gdbsupport/common-utils.h" 75 76/* Forward declarations for local functions. */ 77 78static void rbreak_command (const char *, int); 79 80static int find_line_common (struct linetable *, int, int *, int); 81 82static struct block_symbol 83 lookup_symbol_aux (const char *name, 84 symbol_name_match_type match_type, 85 const struct block *block, 86 const domain_enum domain, 87 enum language language, 88 struct field_of_this_result *); 89 90static 91struct block_symbol lookup_local_symbol (const char *name, 92 symbol_name_match_type match_type, 93 const struct block *block, 94 const domain_enum domain, 95 enum language language); 96 97static struct block_symbol 98 lookup_symbol_in_objfile (struct objfile *objfile, 99 enum block_enum block_index, 100 const char *name, const domain_enum domain); 101 102/* Type of the data stored on the program space. */ 103 104struct main_info 105{ 106 main_info () = default; 107 108 ~main_info () 109 { 110 xfree (name_of_main); 111 } 112 113 /* Name of "main". */ 114 115 char *name_of_main = nullptr; 116 117 /* Language of "main". */ 118 119 enum language language_of_main = language_unknown; 120}; 121 122/* Program space key for finding name and language of "main". */ 123 124static const registry<program_space>::key<main_info> main_progspace_key; 125 126/* The default symbol cache size. 127 There is no extra cpu cost for large N (except when flushing the cache, 128 which is rare). The value here is just a first attempt. A better default 129 value may be higher or lower. A prime number can make up for a bad hash 130 computation, so that's why the number is what it is. */ 131#define DEFAULT_SYMBOL_CACHE_SIZE 1021 132 133/* The maximum symbol cache size. 134 There's no method to the decision of what value to use here, other than 135 there's no point in allowing a user typo to make gdb consume all memory. */ 136#define MAX_SYMBOL_CACHE_SIZE (1024*1024) 137 138/* symbol_cache_lookup returns this if a previous lookup failed to find the 139 symbol in any objfile. */ 140#define SYMBOL_LOOKUP_FAILED \ 141 ((struct block_symbol) {(struct symbol *) 1, NULL}) 142#define SYMBOL_LOOKUP_FAILED_P(SIB) (SIB.symbol == (struct symbol *) 1) 143 144/* Recording lookups that don't find the symbol is just as important, if not 145 more so, than recording found symbols. */ 146 147enum symbol_cache_slot_state 148{ 149 SYMBOL_SLOT_UNUSED, 150 SYMBOL_SLOT_NOT_FOUND, 151 SYMBOL_SLOT_FOUND 152}; 153 154struct symbol_cache_slot 155{ 156 enum symbol_cache_slot_state state; 157 158 /* The objfile that was current when the symbol was looked up. 159 This is only needed for global blocks, but for simplicity's sake 160 we allocate the space for both. If data shows the extra space used 161 for static blocks is a problem, we can split things up then. 162 163 Global blocks need cache lookup to include the objfile context because 164 we need to account for gdbarch_iterate_over_objfiles_in_search_order 165 which can traverse objfiles in, effectively, any order, depending on 166 the current objfile, thus affecting which symbol is found. Normally, 167 only the current objfile is searched first, and then the rest are 168 searched in recorded order; but putting cache lookup inside 169 gdbarch_iterate_over_objfiles_in_search_order would be awkward. 170 Instead we just make the current objfile part of the context of 171 cache lookup. This means we can record the same symbol multiple times, 172 each with a different "current objfile" that was in effect when the 173 lookup was saved in the cache, but cache space is pretty cheap. */ 174 const struct objfile *objfile_context; 175 176 union 177 { 178 struct block_symbol found; 179 struct 180 { 181 char *name; 182 domain_enum domain; 183 } not_found; 184 } value; 185}; 186 187/* Clear out SLOT. */ 188 189static void 190symbol_cache_clear_slot (struct symbol_cache_slot *slot) 191{ 192 if (slot->state == SYMBOL_SLOT_NOT_FOUND) 193 xfree (slot->value.not_found.name); 194 slot->state = SYMBOL_SLOT_UNUSED; 195} 196 197/* Symbols don't specify global vs static block. 198 So keep them in separate caches. */ 199 200struct block_symbol_cache 201{ 202 unsigned int hits; 203 unsigned int misses; 204 unsigned int collisions; 205 206 /* SYMBOLS is a variable length array of this size. 207 One can imagine that in general one cache (global/static) should be a 208 fraction of the size of the other, but there's no data at the moment 209 on which to decide. */ 210 unsigned int size; 211 212 struct symbol_cache_slot symbols[1]; 213}; 214 215/* Clear all slots of BSC and free BSC. */ 216 217static void 218destroy_block_symbol_cache (struct block_symbol_cache *bsc) 219{ 220 if (bsc != nullptr) 221 { 222 for (unsigned int i = 0; i < bsc->size; i++) 223 symbol_cache_clear_slot (&bsc->symbols[i]); 224 xfree (bsc); 225 } 226} 227 228/* The symbol cache. 229 230 Searching for symbols in the static and global blocks over multiple objfiles 231 again and again can be slow, as can searching very big objfiles. This is a 232 simple cache to improve symbol lookup performance, which is critical to 233 overall gdb performance. 234 235 Symbols are hashed on the name, its domain, and block. 236 They are also hashed on their objfile for objfile-specific lookups. */ 237 238struct symbol_cache 239{ 240 symbol_cache () = default; 241 242 ~symbol_cache () 243 { 244 destroy_block_symbol_cache (global_symbols); 245 destroy_block_symbol_cache (static_symbols); 246 } 247 248 struct block_symbol_cache *global_symbols = nullptr; 249 struct block_symbol_cache *static_symbols = nullptr; 250}; 251 252/* Program space key for finding its symbol cache. */ 253 254static const registry<program_space>::key<symbol_cache> symbol_cache_key; 255 256/* When non-zero, print debugging messages related to symtab creation. */ 257unsigned int symtab_create_debug = 0; 258 259/* When non-zero, print debugging messages related to symbol lookup. */ 260unsigned int symbol_lookup_debug = 0; 261 262/* The size of the cache is staged here. */ 263static unsigned int new_symbol_cache_size = DEFAULT_SYMBOL_CACHE_SIZE; 264 265/* The current value of the symbol cache size. 266 This is saved so that if the user enters a value too big we can restore 267 the original value from here. */ 268static unsigned int symbol_cache_size = DEFAULT_SYMBOL_CACHE_SIZE; 269 270/* True if a file may be known by two different basenames. 271 This is the uncommon case, and significantly slows down gdb. 272 Default set to "off" to not slow down the common case. */ 273bool basenames_may_differ = false; 274 275/* Allow the user to configure the debugger behavior with respect 276 to multiple-choice menus when more than one symbol matches during 277 a symbol lookup. */ 278 279const char multiple_symbols_ask[] = "ask"; 280const char multiple_symbols_all[] = "all"; 281const char multiple_symbols_cancel[] = "cancel"; 282static const char *const multiple_symbols_modes[] = 283{ 284 multiple_symbols_ask, 285 multiple_symbols_all, 286 multiple_symbols_cancel, 287 NULL 288}; 289static const char *multiple_symbols_mode = multiple_symbols_all; 290 291/* When TRUE, ignore the prologue-end flag in linetable_entry when searching 292 for the SAL past a function prologue. */ 293static bool ignore_prologue_end_flag = false; 294 295/* Read-only accessor to AUTO_SELECT_MODE. */ 296 297const char * 298multiple_symbols_select_mode (void) 299{ 300 return multiple_symbols_mode; 301} 302 303/* Return the name of a domain_enum. */ 304 305const char * 306domain_name (domain_enum e) 307{ 308 switch (e) 309 { 310 case UNDEF_DOMAIN: return "UNDEF_DOMAIN"; 311 case VAR_DOMAIN: return "VAR_DOMAIN"; 312 case STRUCT_DOMAIN: return "STRUCT_DOMAIN"; 313 case MODULE_DOMAIN: return "MODULE_DOMAIN"; 314 case LABEL_DOMAIN: return "LABEL_DOMAIN"; 315 case COMMON_BLOCK_DOMAIN: return "COMMON_BLOCK_DOMAIN"; 316 default: gdb_assert_not_reached ("bad domain_enum"); 317 } 318} 319 320/* Return the name of a search_domain . */ 321 322const char * 323search_domain_name (enum search_domain e) 324{ 325 switch (e) 326 { 327 case VARIABLES_DOMAIN: return "VARIABLES_DOMAIN"; 328 case FUNCTIONS_DOMAIN: return "FUNCTIONS_DOMAIN"; 329 case TYPES_DOMAIN: return "TYPES_DOMAIN"; 330 case MODULES_DOMAIN: return "MODULES_DOMAIN"; 331 case ALL_DOMAIN: return "ALL_DOMAIN"; 332 default: gdb_assert_not_reached ("bad search_domain"); 333 } 334} 335 336/* See symtab.h. */ 337 338call_site * 339compunit_symtab::find_call_site (CORE_ADDR pc) const 340{ 341 if (m_call_site_htab == nullptr) 342 return nullptr; 343 344 CORE_ADDR delta 345 = this->objfile ()->section_offsets[this->block_line_section ()]; 346 CORE_ADDR unrelocated_pc = pc - delta; 347 348 struct call_site call_site_local (unrelocated_pc, nullptr, nullptr); 349 void **slot 350 = htab_find_slot (m_call_site_htab, &call_site_local, NO_INSERT); 351 if (slot == nullptr) 352 return nullptr; 353 354 return (call_site *) *slot; 355} 356 357/* See symtab.h. */ 358 359void 360compunit_symtab::set_call_site_htab (htab_t call_site_htab) 361{ 362 gdb_assert (m_call_site_htab == nullptr); 363 m_call_site_htab = call_site_htab; 364} 365 366/* See symtab.h. */ 367 368void 369compunit_symtab::set_primary_filetab (symtab *primary_filetab) 370{ 371 symtab *prev_filetab = nullptr; 372 373 /* Move PRIMARY_FILETAB to the head of the filetab list. */ 374 for (symtab *filetab : this->filetabs ()) 375 { 376 if (filetab == primary_filetab) 377 { 378 if (prev_filetab != nullptr) 379 { 380 prev_filetab->next = primary_filetab->next; 381 primary_filetab->next = m_filetabs; 382 m_filetabs = primary_filetab; 383 } 384 385 break; 386 } 387 388 prev_filetab = filetab; 389 } 390 391 gdb_assert (primary_filetab == m_filetabs); 392} 393 394/* See symtab.h. */ 395 396struct symtab * 397compunit_symtab::primary_filetab () const 398{ 399 gdb_assert (m_filetabs != nullptr); 400 401 /* The primary file symtab is the first one in the list. */ 402 return m_filetabs; 403} 404 405/* See symtab.h. */ 406 407enum language 408compunit_symtab::language () const 409{ 410 struct symtab *symtab = primary_filetab (); 411 412 /* The language of the compunit symtab is the language of its 413 primary source file. */ 414 return symtab->language (); 415} 416 417/* The relocated address of the minimal symbol, using the section 418 offsets from OBJFILE. */ 419 420CORE_ADDR 421minimal_symbol::value_address (objfile *objfile) const 422{ 423 if (this->maybe_copied) 424 return get_msymbol_address (objfile, this); 425 else 426 return (this->value_raw_address () 427 + objfile->section_offsets[this->section_index ()]); 428} 429 430/* See symtab.h. */ 431 432bool 433minimal_symbol::data_p () const 434{ 435 return m_type == mst_data 436 || m_type == mst_bss 437 || m_type == mst_abs 438 || m_type == mst_file_data 439 || m_type == mst_file_bss; 440} 441 442/* See symtab.h. */ 443 444bool 445minimal_symbol::text_p () const 446{ 447 return m_type == mst_text 448 || m_type == mst_text_gnu_ifunc 449 || m_type == mst_data_gnu_ifunc 450 || m_type == mst_slot_got_plt 451 || m_type == mst_solib_trampoline 452 || m_type == mst_file_text; 453} 454 455/* See whether FILENAME matches SEARCH_NAME using the rule that we 456 advertise to the user. (The manual's description of linespecs 457 describes what we advertise). Returns true if they match, false 458 otherwise. */ 459 460bool 461compare_filenames_for_search (const char *filename, const char *search_name) 462{ 463 int len = strlen (filename); 464 size_t search_len = strlen (search_name); 465 466 if (len < search_len) 467 return false; 468 469 /* The tail of FILENAME must match. */ 470 if (FILENAME_CMP (filename + len - search_len, search_name) != 0) 471 return false; 472 473 /* Either the names must completely match, or the character 474 preceding the trailing SEARCH_NAME segment of FILENAME must be a 475 directory separator. 476 477 The check !IS_ABSOLUTE_PATH ensures SEARCH_NAME "/dir/file.c" 478 cannot match FILENAME "/path//dir/file.c" - as user has requested 479 absolute path. The sama applies for "c:\file.c" possibly 480 incorrectly hypothetically matching "d:\dir\c:\file.c". 481 482 The HAS_DRIVE_SPEC purpose is to make FILENAME "c:file.c" 483 compatible with SEARCH_NAME "file.c". In such case a compiler had 484 to put the "c:file.c" name into debug info. Such compatibility 485 works only on GDB built for DOS host. */ 486 return (len == search_len 487 || (!IS_ABSOLUTE_PATH (search_name) 488 && IS_DIR_SEPARATOR (filename[len - search_len - 1])) 489 || (HAS_DRIVE_SPEC (filename) 490 && STRIP_DRIVE_SPEC (filename) == &filename[len - search_len])); 491} 492 493/* Same as compare_filenames_for_search, but for glob-style patterns. 494 Heads up on the order of the arguments. They match the order of 495 compare_filenames_for_search, but it's the opposite of the order of 496 arguments to gdb_filename_fnmatch. */ 497 498bool 499compare_glob_filenames_for_search (const char *filename, 500 const char *search_name) 501{ 502 /* We rely on the property of glob-style patterns with FNM_FILE_NAME that 503 all /s have to be explicitly specified. */ 504 int file_path_elements = count_path_elements (filename); 505 int search_path_elements = count_path_elements (search_name); 506 507 if (search_path_elements > file_path_elements) 508 return false; 509 510 if (IS_ABSOLUTE_PATH (search_name)) 511 { 512 return (search_path_elements == file_path_elements 513 && gdb_filename_fnmatch (search_name, filename, 514 FNM_FILE_NAME | FNM_NOESCAPE) == 0); 515 } 516 517 { 518 const char *file_to_compare 519 = strip_leading_path_elements (filename, 520 file_path_elements - search_path_elements); 521 522 return gdb_filename_fnmatch (search_name, file_to_compare, 523 FNM_FILE_NAME | FNM_NOESCAPE) == 0; 524 } 525} 526 527/* Check for a symtab of a specific name by searching some symtabs. 528 This is a helper function for callbacks of iterate_over_symtabs. 529 530 If NAME is not absolute, then REAL_PATH is NULL 531 If NAME is absolute, then REAL_PATH is the gdb_realpath form of NAME. 532 533 The return value, NAME, REAL_PATH and CALLBACK are identical to the 534 `map_symtabs_matching_filename' method of quick_symbol_functions. 535 536 FIRST and AFTER_LAST indicate the range of compunit symtabs to search. 537 Each symtab within the specified compunit symtab is also searched. 538 AFTER_LAST is one past the last compunit symtab to search; NULL means to 539 search until the end of the list. */ 540 541bool 542iterate_over_some_symtabs (const char *name, 543 const char *real_path, 544 struct compunit_symtab *first, 545 struct compunit_symtab *after_last, 546 gdb::function_view<bool (symtab *)> callback) 547{ 548 struct compunit_symtab *cust; 549 const char* base_name = lbasename (name); 550 551 for (cust = first; cust != NULL && cust != after_last; cust = cust->next) 552 { 553 for (symtab *s : cust->filetabs ()) 554 { 555 if (compare_filenames_for_search (s->filename, name)) 556 { 557 if (callback (s)) 558 return true; 559 continue; 560 } 561 562 /* Before we invoke realpath, which can get expensive when many 563 files are involved, do a quick comparison of the basenames. */ 564 if (! basenames_may_differ 565 && FILENAME_CMP (base_name, lbasename (s->filename)) != 0) 566 continue; 567 568 if (compare_filenames_for_search (symtab_to_fullname (s), name)) 569 { 570 if (callback (s)) 571 return true; 572 continue; 573 } 574 575 /* If the user gave us an absolute path, try to find the file in 576 this symtab and use its absolute path. */ 577 if (real_path != NULL) 578 { 579 const char *fullname = symtab_to_fullname (s); 580 581 gdb_assert (IS_ABSOLUTE_PATH (real_path)); 582 gdb_assert (IS_ABSOLUTE_PATH (name)); 583 gdb::unique_xmalloc_ptr<char> fullname_real_path 584 = gdb_realpath (fullname); 585 fullname = fullname_real_path.get (); 586 if (FILENAME_CMP (real_path, fullname) == 0) 587 { 588 if (callback (s)) 589 return true; 590 continue; 591 } 592 } 593 } 594 } 595 596 return false; 597} 598 599/* Check for a symtab of a specific name; first in symtabs, then in 600 psymtabs. *If* there is no '/' in the name, a match after a '/' 601 in the symtab filename will also work. 602 603 Calls CALLBACK with each symtab that is found. If CALLBACK returns 604 true, the search stops. */ 605 606void 607iterate_over_symtabs (const char *name, 608 gdb::function_view<bool (symtab *)> callback) 609{ 610 gdb::unique_xmalloc_ptr<char> real_path; 611 612 /* Here we are interested in canonicalizing an absolute path, not 613 absolutizing a relative path. */ 614 if (IS_ABSOLUTE_PATH (name)) 615 { 616 real_path = gdb_realpath (name); 617 gdb_assert (IS_ABSOLUTE_PATH (real_path.get ())); 618 } 619 620 for (objfile *objfile : current_program_space->objfiles ()) 621 { 622 if (iterate_over_some_symtabs (name, real_path.get (), 623 objfile->compunit_symtabs, NULL, 624 callback)) 625 return; 626 } 627 628 /* Same search rules as above apply here, but now we look thru the 629 psymtabs. */ 630 631 for (objfile *objfile : current_program_space->objfiles ()) 632 { 633 if (objfile->map_symtabs_matching_filename (name, real_path.get (), 634 callback)) 635 return; 636 } 637} 638 639/* A wrapper for iterate_over_symtabs that returns the first matching 640 symtab, or NULL. */ 641 642struct symtab * 643lookup_symtab (const char *name) 644{ 645 struct symtab *result = NULL; 646 647 iterate_over_symtabs (name, [&] (symtab *symtab) 648 { 649 result = symtab; 650 return true; 651 }); 652 653 return result; 654} 655 656 657/* Mangle a GDB method stub type. This actually reassembles the pieces of the 658 full method name, which consist of the class name (from T), the unadorned 659 method name from METHOD_ID, and the signature for the specific overload, 660 specified by SIGNATURE_ID. Note that this function is g++ specific. */ 661 662char * 663gdb_mangle_name (struct type *type, int method_id, int signature_id) 664{ 665 int mangled_name_len; 666 char *mangled_name; 667 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id); 668 struct fn_field *method = &f[signature_id]; 669 const char *field_name = TYPE_FN_FIELDLIST_NAME (type, method_id); 670 const char *physname = TYPE_FN_FIELD_PHYSNAME (f, signature_id); 671 const char *newname = type->name (); 672 673 /* Does the form of physname indicate that it is the full mangled name 674 of a constructor (not just the args)? */ 675 int is_full_physname_constructor; 676 677 int is_constructor; 678 int is_destructor = is_destructor_name (physname); 679 /* Need a new type prefix. */ 680 const char *const_prefix = method->is_const ? "C" : ""; 681 const char *volatile_prefix = method->is_volatile ? "V" : ""; 682 char buf[20]; 683 int len = (newname == NULL ? 0 : strlen (newname)); 684 685 /* Nothing to do if physname already contains a fully mangled v3 abi name 686 or an operator name. */ 687 if ((physname[0] == '_' && physname[1] == 'Z') 688 || is_operator_name (field_name)) 689 return xstrdup (physname); 690 691 is_full_physname_constructor = is_constructor_name (physname); 692 693 is_constructor = is_full_physname_constructor 694 || (newname && strcmp (field_name, newname) == 0); 695 696 if (!is_destructor) 697 is_destructor = (startswith (physname, "__dt")); 698 699 if (is_destructor || is_full_physname_constructor) 700 { 701 mangled_name = (char *) xmalloc (strlen (physname) + 1); 702 strcpy (mangled_name, physname); 703 return mangled_name; 704 } 705 706 if (len == 0) 707 { 708 xsnprintf (buf, sizeof (buf), "__%s%s", const_prefix, volatile_prefix); 709 } 710 else if (physname[0] == 't' || physname[0] == 'Q') 711 { 712 /* The physname for template and qualified methods already includes 713 the class name. */ 714 xsnprintf (buf, sizeof (buf), "__%s%s", const_prefix, volatile_prefix); 715 newname = NULL; 716 len = 0; 717 } 718 else 719 { 720 xsnprintf (buf, sizeof (buf), "__%s%s%d", const_prefix, 721 volatile_prefix, len); 722 } 723 mangled_name_len = ((is_constructor ? 0 : strlen (field_name)) 724 + strlen (buf) + len + strlen (physname) + 1); 725 726 mangled_name = (char *) xmalloc (mangled_name_len); 727 if (is_constructor) 728 mangled_name[0] = '\0'; 729 else 730 strcpy (mangled_name, field_name); 731 732 strcat (mangled_name, buf); 733 /* If the class doesn't have a name, i.e. newname NULL, then we just 734 mangle it using 0 for the length of the class. Thus it gets mangled 735 as something starting with `::' rather than `classname::'. */ 736 if (newname != NULL) 737 strcat (mangled_name, newname); 738 739 strcat (mangled_name, physname); 740 return (mangled_name); 741} 742 743/* See symtab.h. */ 744 745void 746general_symbol_info::set_demangled_name (const char *name, 747 struct obstack *obstack) 748{ 749 if (language () == language_ada) 750 { 751 if (name == NULL) 752 { 753 ada_mangled = 0; 754 language_specific.obstack = obstack; 755 } 756 else 757 { 758 ada_mangled = 1; 759 language_specific.demangled_name = name; 760 } 761 } 762 else 763 language_specific.demangled_name = name; 764} 765 766 767/* Initialize the language dependent portion of a symbol 768 depending upon the language for the symbol. */ 769 770void 771general_symbol_info::set_language (enum language language, 772 struct obstack *obstack) 773{ 774 m_language = language; 775 if (language == language_cplus 776 || language == language_d 777 || language == language_go 778 || language == language_objc 779 || language == language_fortran) 780 { 781 set_demangled_name (NULL, obstack); 782 } 783 else if (language == language_ada) 784 { 785 gdb_assert (ada_mangled == 0); 786 language_specific.obstack = obstack; 787 } 788 else 789 { 790 memset (&language_specific, 0, sizeof (language_specific)); 791 } 792} 793 794/* Functions to initialize a symbol's mangled name. */ 795 796/* Objects of this type are stored in the demangled name hash table. */ 797struct demangled_name_entry 798{ 799 demangled_name_entry (gdb::string_view mangled_name) 800 : mangled (mangled_name) {} 801 802 gdb::string_view mangled; 803 enum language language; 804 gdb::unique_xmalloc_ptr<char> demangled; 805}; 806 807/* Hash function for the demangled name hash. */ 808 809static hashval_t 810hash_demangled_name_entry (const void *data) 811{ 812 const struct demangled_name_entry *e 813 = (const struct demangled_name_entry *) data; 814 815 return fast_hash (e->mangled.data (), e->mangled.length ()); 816} 817 818/* Equality function for the demangled name hash. */ 819 820static int 821eq_demangled_name_entry (const void *a, const void *b) 822{ 823 const struct demangled_name_entry *da 824 = (const struct demangled_name_entry *) a; 825 const struct demangled_name_entry *db 826 = (const struct demangled_name_entry *) b; 827 828 return da->mangled == db->mangled; 829} 830 831static void 832free_demangled_name_entry (void *data) 833{ 834 struct demangled_name_entry *e 835 = (struct demangled_name_entry *) data; 836 837 e->~demangled_name_entry(); 838} 839 840/* Create the hash table used for demangled names. Each hash entry is 841 a pair of strings; one for the mangled name and one for the demangled 842 name. The entry is hashed via just the mangled name. */ 843 844static void 845create_demangled_names_hash (struct objfile_per_bfd_storage *per_bfd) 846{ 847 /* Choose 256 as the starting size of the hash table, somewhat arbitrarily. 848 The hash table code will round this up to the next prime number. 849 Choosing a much larger table size wastes memory, and saves only about 850 1% in symbol reading. However, if the minsym count is already 851 initialized (e.g. because symbol name setting was deferred to 852 a background thread) we can initialize the hashtable with a count 853 based on that, because we will almost certainly have at least that 854 many entries. If we have a nonzero number but less than 256, 855 we still stay with 256 to have some space for psymbols, etc. */ 856 857 /* htab will expand the table when it is 3/4th full, so we account for that 858 here. +2 to round up. */ 859 int minsym_based_count = (per_bfd->minimal_symbol_count + 2) / 3 * 4; 860 int count = std::max (per_bfd->minimal_symbol_count, minsym_based_count); 861 862 per_bfd->demangled_names_hash.reset (htab_create_alloc 863 (count, hash_demangled_name_entry, eq_demangled_name_entry, 864 free_demangled_name_entry, xcalloc, xfree)); 865} 866 867/* See symtab.h */ 868 869gdb::unique_xmalloc_ptr<char> 870symbol_find_demangled_name (struct general_symbol_info *gsymbol, 871 const char *mangled) 872{ 873 gdb::unique_xmalloc_ptr<char> demangled; 874 int i; 875 876 if (gsymbol->language () == language_unknown) 877 gsymbol->m_language = language_auto; 878 879 if (gsymbol->language () != language_auto) 880 { 881 const struct language_defn *lang = language_def (gsymbol->language ()); 882 883 lang->sniff_from_mangled_name (mangled, &demangled); 884 return demangled; 885 } 886 887 for (i = language_unknown; i < nr_languages; ++i) 888 { 889 enum language l = (enum language) i; 890 const struct language_defn *lang = language_def (l); 891 892 if (lang->sniff_from_mangled_name (mangled, &demangled)) 893 { 894 gsymbol->m_language = l; 895 return demangled; 896 } 897 } 898 899 return NULL; 900} 901 902/* Set both the mangled and demangled (if any) names for GSYMBOL based 903 on LINKAGE_NAME and LEN. Ordinarily, NAME is copied onto the 904 objfile's obstack; but if COPY_NAME is 0 and if NAME is 905 NUL-terminated, then this function assumes that NAME is already 906 correctly saved (either permanently or with a lifetime tied to the 907 objfile), and it will not be copied. 908 909 The hash table corresponding to OBJFILE is used, and the memory 910 comes from the per-BFD storage_obstack. LINKAGE_NAME is copied, 911 so the pointer can be discarded after calling this function. */ 912 913void 914general_symbol_info::compute_and_set_names (gdb::string_view linkage_name, 915 bool copy_name, 916 objfile_per_bfd_storage *per_bfd, 917 gdb::optional<hashval_t> hash) 918{ 919 struct demangled_name_entry **slot; 920 921 if (language () == language_ada) 922 { 923 /* In Ada, we do the symbol lookups using the mangled name, so 924 we can save some space by not storing the demangled name. */ 925 if (!copy_name) 926 m_name = linkage_name.data (); 927 else 928 m_name = obstack_strndup (&per_bfd->storage_obstack, 929 linkage_name.data (), 930 linkage_name.length ()); 931 set_demangled_name (NULL, &per_bfd->storage_obstack); 932 933 return; 934 } 935 936 if (per_bfd->demangled_names_hash == NULL) 937 create_demangled_names_hash (per_bfd); 938 939 struct demangled_name_entry entry (linkage_name); 940 if (!hash.has_value ()) 941 hash = hash_demangled_name_entry (&entry); 942 slot = ((struct demangled_name_entry **) 943 htab_find_slot_with_hash (per_bfd->demangled_names_hash.get (), 944 &entry, *hash, INSERT)); 945 946 /* The const_cast is safe because the only reason it is already 947 initialized is if we purposefully set it from a background 948 thread to avoid doing the work here. However, it is still 949 allocated from the heap and needs to be freed by us, just 950 like if we called symbol_find_demangled_name here. If this is 951 nullptr, we call symbol_find_demangled_name below, but we put 952 this smart pointer here to be sure that we don't leak this name. */ 953 gdb::unique_xmalloc_ptr<char> demangled_name 954 (const_cast<char *> (language_specific.demangled_name)); 955 956 /* If this name is not in the hash table, add it. */ 957 if (*slot == NULL 958 /* A C version of the symbol may have already snuck into the table. 959 This happens to, e.g., main.init (__go_init_main). Cope. */ 960 || (language () == language_go && (*slot)->demangled == nullptr)) 961 { 962 /* A 0-terminated copy of the linkage name. Callers must set COPY_NAME 963 to true if the string might not be nullterminated. We have to make 964 this copy because demangling needs a nullterminated string. */ 965 gdb::string_view linkage_name_copy; 966 if (copy_name) 967 { 968 char *alloc_name = (char *) alloca (linkage_name.length () + 1); 969 memcpy (alloc_name, linkage_name.data (), linkage_name.length ()); 970 alloc_name[linkage_name.length ()] = '\0'; 971 972 linkage_name_copy = gdb::string_view (alloc_name, 973 linkage_name.length ()); 974 } 975 else 976 linkage_name_copy = linkage_name; 977 978 if (demangled_name.get () == nullptr) 979 demangled_name 980 = symbol_find_demangled_name (this, linkage_name_copy.data ()); 981 982 /* Suppose we have demangled_name==NULL, copy_name==0, and 983 linkage_name_copy==linkage_name. In this case, we already have the 984 mangled name saved, and we don't have a demangled name. So, 985 you might think we could save a little space by not recording 986 this in the hash table at all. 987 988 It turns out that it is actually important to still save such 989 an entry in the hash table, because storing this name gives 990 us better bcache hit rates for partial symbols. */ 991 if (!copy_name) 992 { 993 *slot 994 = ((struct demangled_name_entry *) 995 obstack_alloc (&per_bfd->storage_obstack, 996 sizeof (demangled_name_entry))); 997 new (*slot) demangled_name_entry (linkage_name); 998 } 999 else 1000 { 1001 /* If we must copy the mangled name, put it directly after 1002 the struct so we can have a single allocation. */ 1003 *slot 1004 = ((struct demangled_name_entry *) 1005 obstack_alloc (&per_bfd->storage_obstack, 1006 sizeof (demangled_name_entry) 1007 + linkage_name.length () + 1)); 1008 char *mangled_ptr = reinterpret_cast<char *> (*slot + 1); 1009 memcpy (mangled_ptr, linkage_name.data (), linkage_name.length ()); 1010 mangled_ptr [linkage_name.length ()] = '\0'; 1011 new (*slot) demangled_name_entry 1012 (gdb::string_view (mangled_ptr, linkage_name.length ())); 1013 } 1014 (*slot)->demangled = std::move (demangled_name); 1015 (*slot)->language = language (); 1016 } 1017 else if (language () == language_unknown || language () == language_auto) 1018 m_language = (*slot)->language; 1019 1020 m_name = (*slot)->mangled.data (); 1021 set_demangled_name ((*slot)->demangled.get (), &per_bfd->storage_obstack); 1022} 1023 1024/* See symtab.h. */ 1025 1026const char * 1027general_symbol_info::natural_name () const 1028{ 1029 switch (language ()) 1030 { 1031 case language_cplus: 1032 case language_d: 1033 case language_go: 1034 case language_objc: 1035 case language_fortran: 1036 case language_rust: 1037 if (language_specific.demangled_name != nullptr) 1038 return language_specific.demangled_name; 1039 break; 1040 case language_ada: 1041 return ada_decode_symbol (this); 1042 default: 1043 break; 1044 } 1045 return linkage_name (); 1046} 1047 1048/* See symtab.h. */ 1049 1050const char * 1051general_symbol_info::demangled_name () const 1052{ 1053 const char *dem_name = NULL; 1054 1055 switch (language ()) 1056 { 1057 case language_cplus: 1058 case language_d: 1059 case language_go: 1060 case language_objc: 1061 case language_fortran: 1062 case language_rust: 1063 dem_name = language_specific.demangled_name; 1064 break; 1065 case language_ada: 1066 dem_name = ada_decode_symbol (this); 1067 break; 1068 default: 1069 break; 1070 } 1071 return dem_name; 1072} 1073 1074/* See symtab.h. */ 1075 1076const char * 1077general_symbol_info::search_name () const 1078{ 1079 if (language () == language_ada) 1080 return linkage_name (); 1081 else 1082 return natural_name (); 1083} 1084 1085/* See symtab.h. */ 1086 1087struct obj_section * 1088general_symbol_info::obj_section (const struct objfile *objfile) const 1089{ 1090 if (section_index () >= 0) 1091 return &objfile->sections[section_index ()]; 1092 return nullptr; 1093} 1094 1095/* See symtab.h. */ 1096 1097bool 1098symbol_matches_search_name (const struct general_symbol_info *gsymbol, 1099 const lookup_name_info &name) 1100{ 1101 symbol_name_matcher_ftype *name_match 1102 = language_def (gsymbol->language ())->get_symbol_name_matcher (name); 1103 return name_match (gsymbol->search_name (), name, NULL); 1104} 1105 1106 1107 1108/* Return true if the two sections are the same, or if they could 1109 plausibly be copies of each other, one in an original object 1110 file and another in a separated debug file. */ 1111 1112bool 1113matching_obj_sections (struct obj_section *obj_first, 1114 struct obj_section *obj_second) 1115{ 1116 asection *first = obj_first? obj_first->the_bfd_section : NULL; 1117 asection *second = obj_second? obj_second->the_bfd_section : NULL; 1118 1119 /* If they're the same section, then they match. */ 1120 if (first == second) 1121 return true; 1122 1123 /* If either is NULL, give up. */ 1124 if (first == NULL || second == NULL) 1125 return false; 1126 1127 /* This doesn't apply to absolute symbols. */ 1128 if (first->owner == NULL || second->owner == NULL) 1129 return false; 1130 1131 /* If they're in the same object file, they must be different sections. */ 1132 if (first->owner == second->owner) 1133 return false; 1134 1135 /* Check whether the two sections are potentially corresponding. They must 1136 have the same size, address, and name. We can't compare section indexes, 1137 which would be more reliable, because some sections may have been 1138 stripped. */ 1139 if (bfd_section_size (first) != bfd_section_size (second)) 1140 return false; 1141 1142 /* In-memory addresses may start at a different offset, relativize them. */ 1143 if (bfd_section_vma (first) - bfd_get_start_address (first->owner) 1144 != bfd_section_vma (second) - bfd_get_start_address (second->owner)) 1145 return false; 1146 1147 if (bfd_section_name (first) == NULL 1148 || bfd_section_name (second) == NULL 1149 || strcmp (bfd_section_name (first), bfd_section_name (second)) != 0) 1150 return false; 1151 1152 /* Otherwise check that they are in corresponding objfiles. */ 1153 1154 struct objfile *obj = NULL; 1155 for (objfile *objfile : current_program_space->objfiles ()) 1156 if (objfile->obfd == first->owner) 1157 { 1158 obj = objfile; 1159 break; 1160 } 1161 gdb_assert (obj != NULL); 1162 1163 if (obj->separate_debug_objfile != NULL 1164 && obj->separate_debug_objfile->obfd == second->owner) 1165 return true; 1166 if (obj->separate_debug_objfile_backlink != NULL 1167 && obj->separate_debug_objfile_backlink->obfd == second->owner) 1168 return true; 1169 1170 return false; 1171} 1172 1173/* See symtab.h. */ 1174 1175void 1176expand_symtab_containing_pc (CORE_ADDR pc, struct obj_section *section) 1177{ 1178 struct bound_minimal_symbol msymbol; 1179 1180 /* If we know that this is not a text address, return failure. This is 1181 necessary because we loop based on texthigh and textlow, which do 1182 not include the data ranges. */ 1183 msymbol = lookup_minimal_symbol_by_pc_section (pc, section); 1184 if (msymbol.minsym && msymbol.minsym->data_p ()) 1185 return; 1186 1187 for (objfile *objfile : current_program_space->objfiles ()) 1188 { 1189 struct compunit_symtab *cust 1190 = objfile->find_pc_sect_compunit_symtab (msymbol, pc, section, 0); 1191 if (cust) 1192 return; 1193 } 1194} 1195 1196/* Hash function for the symbol cache. */ 1197 1198static unsigned int 1199hash_symbol_entry (const struct objfile *objfile_context, 1200 const char *name, domain_enum domain) 1201{ 1202 unsigned int hash = (uintptr_t) objfile_context; 1203 1204 if (name != NULL) 1205 hash += htab_hash_string (name); 1206 1207 /* Because of symbol_matches_domain we need VAR_DOMAIN and STRUCT_DOMAIN 1208 to map to the same slot. */ 1209 if (domain == STRUCT_DOMAIN) 1210 hash += VAR_DOMAIN * 7; 1211 else 1212 hash += domain * 7; 1213 1214 return hash; 1215} 1216 1217/* Equality function for the symbol cache. */ 1218 1219static int 1220eq_symbol_entry (const struct symbol_cache_slot *slot, 1221 const struct objfile *objfile_context, 1222 const char *name, domain_enum domain) 1223{ 1224 const char *slot_name; 1225 domain_enum slot_domain; 1226 1227 if (slot->state == SYMBOL_SLOT_UNUSED) 1228 return 0; 1229 1230 if (slot->objfile_context != objfile_context) 1231 return 0; 1232 1233 if (slot->state == SYMBOL_SLOT_NOT_FOUND) 1234 { 1235 slot_name = slot->value.not_found.name; 1236 slot_domain = slot->value.not_found.domain; 1237 } 1238 else 1239 { 1240 slot_name = slot->value.found.symbol->search_name (); 1241 slot_domain = slot->value.found.symbol->domain (); 1242 } 1243 1244 /* NULL names match. */ 1245 if (slot_name == NULL && name == NULL) 1246 { 1247 /* But there's no point in calling symbol_matches_domain in the 1248 SYMBOL_SLOT_FOUND case. */ 1249 if (slot_domain != domain) 1250 return 0; 1251 } 1252 else if (slot_name != NULL && name != NULL) 1253 { 1254 /* It's important that we use the same comparison that was done 1255 the first time through. If the slot records a found symbol, 1256 then this means using the symbol name comparison function of 1257 the symbol's language with symbol->search_name (). See 1258 dictionary.c. It also means using symbol_matches_domain for 1259 found symbols. See block.c. 1260 1261 If the slot records a not-found symbol, then require a precise match. 1262 We could still be lax with whitespace like strcmp_iw though. */ 1263 1264 if (slot->state == SYMBOL_SLOT_NOT_FOUND) 1265 { 1266 if (strcmp (slot_name, name) != 0) 1267 return 0; 1268 if (slot_domain != domain) 1269 return 0; 1270 } 1271 else 1272 { 1273 struct symbol *sym = slot->value.found.symbol; 1274 lookup_name_info lookup_name (name, symbol_name_match_type::FULL); 1275 1276 if (!symbol_matches_search_name (sym, lookup_name)) 1277 return 0; 1278 1279 if (!symbol_matches_domain (sym->language (), slot_domain, domain)) 1280 return 0; 1281 } 1282 } 1283 else 1284 { 1285 /* Only one name is NULL. */ 1286 return 0; 1287 } 1288 1289 return 1; 1290} 1291 1292/* Given a cache of size SIZE, return the size of the struct (with variable 1293 length array) in bytes. */ 1294 1295static size_t 1296symbol_cache_byte_size (unsigned int size) 1297{ 1298 return (sizeof (struct block_symbol_cache) 1299 + ((size - 1) * sizeof (struct symbol_cache_slot))); 1300} 1301 1302/* Resize CACHE. */ 1303 1304static void 1305resize_symbol_cache (struct symbol_cache *cache, unsigned int new_size) 1306{ 1307 /* If there's no change in size, don't do anything. 1308 All caches have the same size, so we can just compare with the size 1309 of the global symbols cache. */ 1310 if ((cache->global_symbols != NULL 1311 && cache->global_symbols->size == new_size) 1312 || (cache->global_symbols == NULL 1313 && new_size == 0)) 1314 return; 1315 1316 destroy_block_symbol_cache (cache->global_symbols); 1317 destroy_block_symbol_cache (cache->static_symbols); 1318 1319 if (new_size == 0) 1320 { 1321 cache->global_symbols = NULL; 1322 cache->static_symbols = NULL; 1323 } 1324 else 1325 { 1326 size_t total_size = symbol_cache_byte_size (new_size); 1327 1328 cache->global_symbols 1329 = (struct block_symbol_cache *) xcalloc (1, total_size); 1330 cache->static_symbols 1331 = (struct block_symbol_cache *) xcalloc (1, total_size); 1332 cache->global_symbols->size = new_size; 1333 cache->static_symbols->size = new_size; 1334 } 1335} 1336 1337/* Return the symbol cache of PSPACE. 1338 Create one if it doesn't exist yet. */ 1339 1340static struct symbol_cache * 1341get_symbol_cache (struct program_space *pspace) 1342{ 1343 struct symbol_cache *cache = symbol_cache_key.get (pspace); 1344 1345 if (cache == NULL) 1346 { 1347 cache = symbol_cache_key.emplace (pspace); 1348 resize_symbol_cache (cache, symbol_cache_size); 1349 } 1350 1351 return cache; 1352} 1353 1354/* Set the size of the symbol cache in all program spaces. */ 1355 1356static void 1357set_symbol_cache_size (unsigned int new_size) 1358{ 1359 for (struct program_space *pspace : program_spaces) 1360 { 1361 struct symbol_cache *cache = symbol_cache_key.get (pspace); 1362 1363 /* The pspace could have been created but not have a cache yet. */ 1364 if (cache != NULL) 1365 resize_symbol_cache (cache, new_size); 1366 } 1367} 1368 1369/* Called when symbol-cache-size is set. */ 1370 1371static void 1372set_symbol_cache_size_handler (const char *args, int from_tty, 1373 struct cmd_list_element *c) 1374{ 1375 if (new_symbol_cache_size > MAX_SYMBOL_CACHE_SIZE) 1376 { 1377 /* Restore the previous value. 1378 This is the value the "show" command prints. */ 1379 new_symbol_cache_size = symbol_cache_size; 1380 1381 error (_("Symbol cache size is too large, max is %u."), 1382 MAX_SYMBOL_CACHE_SIZE); 1383 } 1384 symbol_cache_size = new_symbol_cache_size; 1385 1386 set_symbol_cache_size (symbol_cache_size); 1387} 1388 1389/* Lookup symbol NAME,DOMAIN in BLOCK in the symbol cache of PSPACE. 1390 OBJFILE_CONTEXT is the current objfile, which may be NULL. 1391 The result is the symbol if found, SYMBOL_LOOKUP_FAILED if a previous lookup 1392 failed (and thus this one will too), or NULL if the symbol is not present 1393 in the cache. 1394 *BSC_PTR and *SLOT_PTR are set to the cache and slot of the symbol, which 1395 can be used to save the result of a full lookup attempt. */ 1396 1397static struct block_symbol 1398symbol_cache_lookup (struct symbol_cache *cache, 1399 struct objfile *objfile_context, enum block_enum block, 1400 const char *name, domain_enum domain, 1401 struct block_symbol_cache **bsc_ptr, 1402 struct symbol_cache_slot **slot_ptr) 1403{ 1404 struct block_symbol_cache *bsc; 1405 unsigned int hash; 1406 struct symbol_cache_slot *slot; 1407 1408 if (block == GLOBAL_BLOCK) 1409 bsc = cache->global_symbols; 1410 else 1411 bsc = cache->static_symbols; 1412 if (bsc == NULL) 1413 { 1414 *bsc_ptr = NULL; 1415 *slot_ptr = NULL; 1416 return {}; 1417 } 1418 1419 hash = hash_symbol_entry (objfile_context, name, domain); 1420 slot = bsc->symbols + hash % bsc->size; 1421 1422 *bsc_ptr = bsc; 1423 *slot_ptr = slot; 1424 1425 if (eq_symbol_entry (slot, objfile_context, name, domain)) 1426 { 1427 symbol_lookup_debug_printf ("%s block symbol cache hit%s for %s, %s", 1428 block == GLOBAL_BLOCK ? "Global" : "Static", 1429 slot->state == SYMBOL_SLOT_NOT_FOUND 1430 ? " (not found)" : "", name, 1431 domain_name (domain)); 1432 ++bsc->hits; 1433 if (slot->state == SYMBOL_SLOT_NOT_FOUND) 1434 return SYMBOL_LOOKUP_FAILED; 1435 return slot->value.found; 1436 } 1437 1438 /* Symbol is not present in the cache. */ 1439 1440 symbol_lookup_debug_printf ("%s block symbol cache miss for %s, %s", 1441 block == GLOBAL_BLOCK ? "Global" : "Static", 1442 name, domain_name (domain)); 1443 ++bsc->misses; 1444 return {}; 1445} 1446 1447/* Mark SYMBOL as found in SLOT. 1448 OBJFILE_CONTEXT is the current objfile when the lookup was done, or NULL 1449 if it's not needed to distinguish lookups (STATIC_BLOCK). It is *not* 1450 necessarily the objfile the symbol was found in. */ 1451 1452static void 1453symbol_cache_mark_found (struct block_symbol_cache *bsc, 1454 struct symbol_cache_slot *slot, 1455 struct objfile *objfile_context, 1456 struct symbol *symbol, 1457 const struct block *block) 1458{ 1459 if (bsc == NULL) 1460 return; 1461 if (slot->state != SYMBOL_SLOT_UNUSED) 1462 { 1463 ++bsc->collisions; 1464 symbol_cache_clear_slot (slot); 1465 } 1466 slot->state = SYMBOL_SLOT_FOUND; 1467 slot->objfile_context = objfile_context; 1468 slot->value.found.symbol = symbol; 1469 slot->value.found.block = block; 1470} 1471 1472/* Mark symbol NAME, DOMAIN as not found in SLOT. 1473 OBJFILE_CONTEXT is the current objfile when the lookup was done, or NULL 1474 if it's not needed to distinguish lookups (STATIC_BLOCK). */ 1475 1476static void 1477symbol_cache_mark_not_found (struct block_symbol_cache *bsc, 1478 struct symbol_cache_slot *slot, 1479 struct objfile *objfile_context, 1480 const char *name, domain_enum domain) 1481{ 1482 if (bsc == NULL) 1483 return; 1484 if (slot->state != SYMBOL_SLOT_UNUSED) 1485 { 1486 ++bsc->collisions; 1487 symbol_cache_clear_slot (slot); 1488 } 1489 slot->state = SYMBOL_SLOT_NOT_FOUND; 1490 slot->objfile_context = objfile_context; 1491 slot->value.not_found.name = xstrdup (name); 1492 slot->value.not_found.domain = domain; 1493} 1494 1495/* Flush the symbol cache of PSPACE. */ 1496 1497static void 1498symbol_cache_flush (struct program_space *pspace) 1499{ 1500 struct symbol_cache *cache = symbol_cache_key.get (pspace); 1501 int pass; 1502 1503 if (cache == NULL) 1504 return; 1505 if (cache->global_symbols == NULL) 1506 { 1507 gdb_assert (symbol_cache_size == 0); 1508 gdb_assert (cache->static_symbols == NULL); 1509 return; 1510 } 1511 1512 /* If the cache is untouched since the last flush, early exit. 1513 This is important for performance during the startup of a program linked 1514 with 100s (or 1000s) of shared libraries. */ 1515 if (cache->global_symbols->misses == 0 1516 && cache->static_symbols->misses == 0) 1517 return; 1518 1519 gdb_assert (cache->global_symbols->size == symbol_cache_size); 1520 gdb_assert (cache->static_symbols->size == symbol_cache_size); 1521 1522 for (pass = 0; pass < 2; ++pass) 1523 { 1524 struct block_symbol_cache *bsc 1525 = pass == 0 ? cache->global_symbols : cache->static_symbols; 1526 unsigned int i; 1527 1528 for (i = 0; i < bsc->size; ++i) 1529 symbol_cache_clear_slot (&bsc->symbols[i]); 1530 } 1531 1532 cache->global_symbols->hits = 0; 1533 cache->global_symbols->misses = 0; 1534 cache->global_symbols->collisions = 0; 1535 cache->static_symbols->hits = 0; 1536 cache->static_symbols->misses = 0; 1537 cache->static_symbols->collisions = 0; 1538} 1539 1540/* Dump CACHE. */ 1541 1542static void 1543symbol_cache_dump (const struct symbol_cache *cache) 1544{ 1545 int pass; 1546 1547 if (cache->global_symbols == NULL) 1548 { 1549 gdb_printf (" <disabled>\n"); 1550 return; 1551 } 1552 1553 for (pass = 0; pass < 2; ++pass) 1554 { 1555 const struct block_symbol_cache *bsc 1556 = pass == 0 ? cache->global_symbols : cache->static_symbols; 1557 unsigned int i; 1558 1559 if (pass == 0) 1560 gdb_printf ("Global symbols:\n"); 1561 else 1562 gdb_printf ("Static symbols:\n"); 1563 1564 for (i = 0; i < bsc->size; ++i) 1565 { 1566 const struct symbol_cache_slot *slot = &bsc->symbols[i]; 1567 1568 QUIT; 1569 1570 switch (slot->state) 1571 { 1572 case SYMBOL_SLOT_UNUSED: 1573 break; 1574 case SYMBOL_SLOT_NOT_FOUND: 1575 gdb_printf (" [%4u] = %s, %s %s (not found)\n", i, 1576 host_address_to_string (slot->objfile_context), 1577 slot->value.not_found.name, 1578 domain_name (slot->value.not_found.domain)); 1579 break; 1580 case SYMBOL_SLOT_FOUND: 1581 { 1582 struct symbol *found = slot->value.found.symbol; 1583 const struct objfile *context = slot->objfile_context; 1584 1585 gdb_printf (" [%4u] = %s, %s %s\n", i, 1586 host_address_to_string (context), 1587 found->print_name (), 1588 domain_name (found->domain ())); 1589 break; 1590 } 1591 } 1592 } 1593 } 1594} 1595 1596/* The "mt print symbol-cache" command. */ 1597 1598static void 1599maintenance_print_symbol_cache (const char *args, int from_tty) 1600{ 1601 for (struct program_space *pspace : program_spaces) 1602 { 1603 struct symbol_cache *cache; 1604 1605 gdb_printf (_("Symbol cache for pspace %d\n%s:\n"), 1606 pspace->num, 1607 pspace->symfile_object_file != NULL 1608 ? objfile_name (pspace->symfile_object_file) 1609 : "(no object file)"); 1610 1611 /* If the cache hasn't been created yet, avoid creating one. */ 1612 cache = symbol_cache_key.get (pspace); 1613 if (cache == NULL) 1614 gdb_printf (" <empty>\n"); 1615 else 1616 symbol_cache_dump (cache); 1617 } 1618} 1619 1620/* The "mt flush-symbol-cache" command. */ 1621 1622static void 1623maintenance_flush_symbol_cache (const char *args, int from_tty) 1624{ 1625 for (struct program_space *pspace : program_spaces) 1626 { 1627 symbol_cache_flush (pspace); 1628 } 1629} 1630 1631/* Print usage statistics of CACHE. */ 1632 1633static void 1634symbol_cache_stats (struct symbol_cache *cache) 1635{ 1636 int pass; 1637 1638 if (cache->global_symbols == NULL) 1639 { 1640 gdb_printf (" <disabled>\n"); 1641 return; 1642 } 1643 1644 for (pass = 0; pass < 2; ++pass) 1645 { 1646 const struct block_symbol_cache *bsc 1647 = pass == 0 ? cache->global_symbols : cache->static_symbols; 1648 1649 QUIT; 1650 1651 if (pass == 0) 1652 gdb_printf ("Global block cache stats:\n"); 1653 else 1654 gdb_printf ("Static block cache stats:\n"); 1655 1656 gdb_printf (" size: %u\n", bsc->size); 1657 gdb_printf (" hits: %u\n", bsc->hits); 1658 gdb_printf (" misses: %u\n", bsc->misses); 1659 gdb_printf (" collisions: %u\n", bsc->collisions); 1660 } 1661} 1662 1663/* The "mt print symbol-cache-statistics" command. */ 1664 1665static void 1666maintenance_print_symbol_cache_statistics (const char *args, int from_tty) 1667{ 1668 for (struct program_space *pspace : program_spaces) 1669 { 1670 struct symbol_cache *cache; 1671 1672 gdb_printf (_("Symbol cache statistics for pspace %d\n%s:\n"), 1673 pspace->num, 1674 pspace->symfile_object_file != NULL 1675 ? objfile_name (pspace->symfile_object_file) 1676 : "(no object file)"); 1677 1678 /* If the cache hasn't been created yet, avoid creating one. */ 1679 cache = symbol_cache_key.get (pspace); 1680 if (cache == NULL) 1681 gdb_printf (" empty, no stats available\n"); 1682 else 1683 symbol_cache_stats (cache); 1684 } 1685} 1686 1687/* This module's 'new_objfile' observer. */ 1688 1689static void 1690symtab_new_objfile_observer (struct objfile *objfile) 1691{ 1692 /* Ideally we'd use OBJFILE->pspace, but OBJFILE may be NULL. */ 1693 symbol_cache_flush (current_program_space); 1694} 1695 1696/* This module's 'free_objfile' observer. */ 1697 1698static void 1699symtab_free_objfile_observer (struct objfile *objfile) 1700{ 1701 symbol_cache_flush (objfile->pspace); 1702} 1703 1704/* Debug symbols usually don't have section information. We need to dig that 1705 out of the minimal symbols and stash that in the debug symbol. */ 1706 1707void 1708fixup_section (struct general_symbol_info *ginfo, 1709 CORE_ADDR addr, struct objfile *objfile) 1710{ 1711 struct minimal_symbol *msym; 1712 1713 /* First, check whether a minimal symbol with the same name exists 1714 and points to the same address. The address check is required 1715 e.g. on PowerPC64, where the minimal symbol for a function will 1716 point to the function descriptor, while the debug symbol will 1717 point to the actual function code. */ 1718 msym = lookup_minimal_symbol_by_pc_name (addr, ginfo->linkage_name (), 1719 objfile); 1720 if (msym) 1721 ginfo->set_section_index (msym->section_index ()); 1722 else 1723 { 1724 /* Static, function-local variables do appear in the linker 1725 (minimal) symbols, but are frequently given names that won't 1726 be found via lookup_minimal_symbol(). E.g., it has been 1727 observed in frv-uclinux (ELF) executables that a static, 1728 function-local variable named "foo" might appear in the 1729 linker symbols as "foo.6" or "foo.3". Thus, there is no 1730 point in attempting to extend the lookup-by-name mechanism to 1731 handle this case due to the fact that there can be multiple 1732 names. 1733 1734 So, instead, search the section table when lookup by name has 1735 failed. The ``addr'' and ``endaddr'' fields may have already 1736 been relocated. If so, the relocation offset needs to be 1737 subtracted from these values when performing the comparison. 1738 We unconditionally subtract it, because, when no relocation 1739 has been performed, the value will simply be zero. 1740 1741 The address of the symbol whose section we're fixing up HAS 1742 NOT BEEN adjusted (relocated) yet. It can't have been since 1743 the section isn't yet known and knowing the section is 1744 necessary in order to add the correct relocation value. In 1745 other words, we wouldn't even be in this function (attempting 1746 to compute the section) if it were already known. 1747 1748 Note that it is possible to search the minimal symbols 1749 (subtracting the relocation value if necessary) to find the 1750 matching minimal symbol, but this is overkill and much less 1751 efficient. It is not necessary to find the matching minimal 1752 symbol, only its section. 1753 1754 Note that this technique (of doing a section table search) 1755 can fail when unrelocated section addresses overlap. For 1756 this reason, we still attempt a lookup by name prior to doing 1757 a search of the section table. */ 1758 1759 struct obj_section *s; 1760 int fallback = -1; 1761 1762 ALL_OBJFILE_OSECTIONS (objfile, s) 1763 { 1764 int idx = s - objfile->sections; 1765 CORE_ADDR offset = objfile->section_offsets[idx]; 1766 1767 if (fallback == -1) 1768 fallback = idx; 1769 1770 if (s->addr () - offset <= addr && addr < s->endaddr () - offset) 1771 { 1772 ginfo->set_section_index (idx); 1773 return; 1774 } 1775 } 1776 1777 /* If we didn't find the section, assume it is in the first 1778 section. If there is no allocated section, then it hardly 1779 matters what we pick, so just pick zero. */ 1780 if (fallback == -1) 1781 ginfo->set_section_index (0); 1782 else 1783 ginfo->set_section_index (fallback); 1784 } 1785} 1786 1787struct symbol * 1788fixup_symbol_section (struct symbol *sym, struct objfile *objfile) 1789{ 1790 CORE_ADDR addr; 1791 1792 if (!sym) 1793 return NULL; 1794 1795 if (!sym->is_objfile_owned ()) 1796 return sym; 1797 1798 /* We either have an OBJFILE, or we can get at it from the sym's 1799 symtab. Anything else is a bug. */ 1800 gdb_assert (objfile || sym->symtab ()); 1801 1802 if (objfile == NULL) 1803 objfile = sym->objfile (); 1804 1805 if (sym->obj_section (objfile) != nullptr) 1806 return sym; 1807 1808 /* We should have an objfile by now. */ 1809 gdb_assert (objfile); 1810 1811 switch (sym->aclass ()) 1812 { 1813 case LOC_STATIC: 1814 case LOC_LABEL: 1815 addr = sym->value_address (); 1816 break; 1817 case LOC_BLOCK: 1818 addr = sym->value_block ()->entry_pc (); 1819 break; 1820 1821 default: 1822 /* Nothing else will be listed in the minsyms -- no use looking 1823 it up. */ 1824 return sym; 1825 } 1826 1827 fixup_section (sym, addr, objfile); 1828 1829 return sym; 1830} 1831 1832/* See symtab.h. */ 1833 1834demangle_for_lookup_info::demangle_for_lookup_info 1835 (const lookup_name_info &lookup_name, language lang) 1836{ 1837 demangle_result_storage storage; 1838 1839 if (lookup_name.ignore_parameters () && lang == language_cplus) 1840 { 1841 gdb::unique_xmalloc_ptr<char> without_params 1842 = cp_remove_params_if_any (lookup_name.c_str (), 1843 lookup_name.completion_mode ()); 1844 1845 if (without_params != NULL) 1846 { 1847 if (lookup_name.match_type () != symbol_name_match_type::SEARCH_NAME) 1848 m_demangled_name = demangle_for_lookup (without_params.get (), 1849 lang, storage); 1850 return; 1851 } 1852 } 1853 1854 if (lookup_name.match_type () == symbol_name_match_type::SEARCH_NAME) 1855 m_demangled_name = lookup_name.c_str (); 1856 else 1857 m_demangled_name = demangle_for_lookup (lookup_name.c_str (), 1858 lang, storage); 1859} 1860 1861/* See symtab.h. */ 1862 1863const lookup_name_info & 1864lookup_name_info::match_any () 1865{ 1866 /* Lookup any symbol that "" would complete. I.e., this matches all 1867 symbol names. */ 1868 static const lookup_name_info lookup_name ("", symbol_name_match_type::FULL, 1869 true); 1870 1871 return lookup_name; 1872} 1873 1874/* Compute the demangled form of NAME as used by the various symbol 1875 lookup functions. The result can either be the input NAME 1876 directly, or a pointer to a buffer owned by the STORAGE object. 1877 1878 For Ada, this function just returns NAME, unmodified. 1879 Normally, Ada symbol lookups are performed using the encoded name 1880 rather than the demangled name, and so it might seem to make sense 1881 for this function to return an encoded version of NAME. 1882 Unfortunately, we cannot do this, because this function is used in 1883 circumstances where it is not appropriate to try to encode NAME. 1884 For instance, when displaying the frame info, we demangle the name 1885 of each parameter, and then perform a symbol lookup inside our 1886 function using that demangled name. In Ada, certain functions 1887 have internally-generated parameters whose name contain uppercase 1888 characters. Encoding those name would result in those uppercase 1889 characters to become lowercase, and thus cause the symbol lookup 1890 to fail. */ 1891 1892const char * 1893demangle_for_lookup (const char *name, enum language lang, 1894 demangle_result_storage &storage) 1895{ 1896 /* If we are using C++, D, or Go, demangle the name before doing a 1897 lookup, so we can always binary search. */ 1898 if (lang == language_cplus) 1899 { 1900 gdb::unique_xmalloc_ptr<char> demangled_name 1901 = gdb_demangle (name, DMGL_ANSI | DMGL_PARAMS); 1902 if (demangled_name != NULL) 1903 return storage.set_malloc_ptr (std::move (demangled_name)); 1904 1905 /* If we were given a non-mangled name, canonicalize it 1906 according to the language (so far only for C++). */ 1907 gdb::unique_xmalloc_ptr<char> canon = cp_canonicalize_string (name); 1908 if (canon != nullptr) 1909 return storage.set_malloc_ptr (std::move (canon)); 1910 } 1911 else if (lang == language_d) 1912 { 1913 gdb::unique_xmalloc_ptr<char> demangled_name = d_demangle (name, 0); 1914 if (demangled_name != NULL) 1915 return storage.set_malloc_ptr (std::move (demangled_name)); 1916 } 1917 else if (lang == language_go) 1918 { 1919 gdb::unique_xmalloc_ptr<char> demangled_name 1920 = language_def (language_go)->demangle_symbol (name, 0); 1921 if (demangled_name != NULL) 1922 return storage.set_malloc_ptr (std::move (demangled_name)); 1923 } 1924 1925 return name; 1926} 1927 1928/* See symtab.h. */ 1929 1930unsigned int 1931search_name_hash (enum language language, const char *search_name) 1932{ 1933 return language_def (language)->search_name_hash (search_name); 1934} 1935 1936/* See symtab.h. 1937 1938 This function (or rather its subordinates) have a bunch of loops and 1939 it would seem to be attractive to put in some QUIT's (though I'm not really 1940 sure whether it can run long enough to be really important). But there 1941 are a few calls for which it would appear to be bad news to quit 1942 out of here: e.g., find_proc_desc in alpha-mdebug-tdep.c. (Note 1943 that there is C++ code below which can error(), but that probably 1944 doesn't affect these calls since they are looking for a known 1945 variable and thus can probably assume it will never hit the C++ 1946 code). */ 1947 1948struct block_symbol 1949lookup_symbol_in_language (const char *name, const struct block *block, 1950 const domain_enum domain, enum language lang, 1951 struct field_of_this_result *is_a_field_of_this) 1952{ 1953 SYMBOL_LOOKUP_SCOPED_DEBUG_ENTER_EXIT; 1954 1955 demangle_result_storage storage; 1956 const char *modified_name = demangle_for_lookup (name, lang, storage); 1957 1958 return lookup_symbol_aux (modified_name, 1959 symbol_name_match_type::FULL, 1960 block, domain, lang, 1961 is_a_field_of_this); 1962} 1963 1964/* See symtab.h. */ 1965 1966struct block_symbol 1967lookup_symbol (const char *name, const struct block *block, 1968 domain_enum domain, 1969 struct field_of_this_result *is_a_field_of_this) 1970{ 1971 return lookup_symbol_in_language (name, block, domain, 1972 current_language->la_language, 1973 is_a_field_of_this); 1974} 1975 1976/* See symtab.h. */ 1977 1978struct block_symbol 1979lookup_symbol_search_name (const char *search_name, const struct block *block, 1980 domain_enum domain) 1981{ 1982 return lookup_symbol_aux (search_name, symbol_name_match_type::SEARCH_NAME, 1983 block, domain, language_asm, NULL); 1984} 1985 1986/* See symtab.h. */ 1987 1988struct block_symbol 1989lookup_language_this (const struct language_defn *lang, 1990 const struct block *block) 1991{ 1992 if (lang->name_of_this () == NULL || block == NULL) 1993 return {}; 1994 1995 symbol_lookup_debug_printf_v ("lookup_language_this (%s, %s (objfile %s))", 1996 lang->name (), host_address_to_string (block), 1997 objfile_debug_name (block_objfile (block))); 1998 1999 while (block) 2000 { 2001 struct symbol *sym; 2002 2003 sym = block_lookup_symbol (block, lang->name_of_this (), 2004 symbol_name_match_type::SEARCH_NAME, 2005 VAR_DOMAIN); 2006 if (sym != NULL) 2007 { 2008 symbol_lookup_debug_printf_v 2009 ("lookup_language_this (...) = %s (%s, block %s)", 2010 sym->print_name (), host_address_to_string (sym), 2011 host_address_to_string (block)); 2012 return (struct block_symbol) {sym, block}; 2013 } 2014 if (block->function ()) 2015 break; 2016 block = block->superblock (); 2017 } 2018 2019 symbol_lookup_debug_printf_v ("lookup_language_this (...) = NULL"); 2020 return {}; 2021} 2022 2023/* Given TYPE, a structure/union, 2024 return 1 if the component named NAME from the ultimate target 2025 structure/union is defined, otherwise, return 0. */ 2026 2027static int 2028check_field (struct type *type, const char *name, 2029 struct field_of_this_result *is_a_field_of_this) 2030{ 2031 int i; 2032 2033 /* The type may be a stub. */ 2034 type = check_typedef (type); 2035 2036 for (i = type->num_fields () - 1; i >= TYPE_N_BASECLASSES (type); i--) 2037 { 2038 const char *t_field_name = type->field (i).name (); 2039 2040 if (t_field_name && (strcmp_iw (t_field_name, name) == 0)) 2041 { 2042 is_a_field_of_this->type = type; 2043 is_a_field_of_this->field = &type->field (i); 2044 return 1; 2045 } 2046 } 2047 2048 /* C++: If it was not found as a data field, then try to return it 2049 as a pointer to a method. */ 2050 2051 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i) 2052 { 2053 if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type, i), name) == 0) 2054 { 2055 is_a_field_of_this->type = type; 2056 is_a_field_of_this->fn_field = &TYPE_FN_FIELDLIST (type, i); 2057 return 1; 2058 } 2059 } 2060 2061 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--) 2062 if (check_field (TYPE_BASECLASS (type, i), name, is_a_field_of_this)) 2063 return 1; 2064 2065 return 0; 2066} 2067 2068/* Behave like lookup_symbol except that NAME is the natural name 2069 (e.g., demangled name) of the symbol that we're looking for. */ 2070 2071static struct block_symbol 2072lookup_symbol_aux (const char *name, symbol_name_match_type match_type, 2073 const struct block *block, 2074 const domain_enum domain, enum language language, 2075 struct field_of_this_result *is_a_field_of_this) 2076{ 2077 SYMBOL_LOOKUP_SCOPED_DEBUG_ENTER_EXIT; 2078 2079 struct block_symbol result; 2080 const struct language_defn *langdef; 2081 2082 if (symbol_lookup_debug) 2083 { 2084 struct objfile *objfile = (block == nullptr 2085 ? nullptr : block_objfile (block)); 2086 2087 symbol_lookup_debug_printf 2088 ("demangled symbol name = \"%s\", block @ %s (objfile %s)", 2089 name, host_address_to_string (block), 2090 objfile != NULL ? objfile_debug_name (objfile) : "NULL"); 2091 symbol_lookup_debug_printf 2092 ("domain name = \"%s\", language = \"%s\")", 2093 domain_name (domain), language_str (language)); 2094 } 2095 2096 /* Make sure we do something sensible with is_a_field_of_this, since 2097 the callers that set this parameter to some non-null value will 2098 certainly use it later. If we don't set it, the contents of 2099 is_a_field_of_this are undefined. */ 2100 if (is_a_field_of_this != NULL) 2101 memset (is_a_field_of_this, 0, sizeof (*is_a_field_of_this)); 2102 2103 /* Search specified block and its superiors. Don't search 2104 STATIC_BLOCK or GLOBAL_BLOCK. */ 2105 2106 result = lookup_local_symbol (name, match_type, block, domain, language); 2107 if (result.symbol != NULL) 2108 { 2109 symbol_lookup_debug_printf 2110 ("found symbol @ %s (using lookup_local_symbol)", 2111 host_address_to_string (result.symbol)); 2112 return result; 2113 } 2114 2115 /* If requested to do so by the caller and if appropriate for LANGUAGE, 2116 check to see if NAME is a field of `this'. */ 2117 2118 langdef = language_def (language); 2119 2120 /* Don't do this check if we are searching for a struct. It will 2121 not be found by check_field, but will be found by other 2122 means. */ 2123 if (is_a_field_of_this != NULL && domain != STRUCT_DOMAIN) 2124 { 2125 result = lookup_language_this (langdef, block); 2126 2127 if (result.symbol) 2128 { 2129 struct type *t = result.symbol->type (); 2130 2131 /* I'm not really sure that type of this can ever 2132 be typedefed; just be safe. */ 2133 t = check_typedef (t); 2134 if (t->is_pointer_or_reference ()) 2135 t = t->target_type (); 2136 2137 if (t->code () != TYPE_CODE_STRUCT 2138 && t->code () != TYPE_CODE_UNION) 2139 error (_("Internal error: `%s' is not an aggregate"), 2140 langdef->name_of_this ()); 2141 2142 if (check_field (t, name, is_a_field_of_this)) 2143 { 2144 symbol_lookup_debug_printf ("no symbol found"); 2145 return {}; 2146 } 2147 } 2148 } 2149 2150 /* Now do whatever is appropriate for LANGUAGE to look 2151 up static and global variables. */ 2152 2153 result = langdef->lookup_symbol_nonlocal (name, block, domain); 2154 if (result.symbol != NULL) 2155 { 2156 symbol_lookup_debug_printf 2157 ("found symbol @ %s (using language lookup_symbol_nonlocal)", 2158 host_address_to_string (result.symbol)); 2159 return result; 2160 } 2161 2162 /* Now search all static file-level symbols. Not strictly correct, 2163 but more useful than an error. */ 2164 2165 result = lookup_static_symbol (name, domain); 2166 symbol_lookup_debug_printf 2167 ("found symbol @ %s (using lookup_static_symbol)", 2168 result.symbol != NULL ? host_address_to_string (result.symbol) : "NULL"); 2169 return result; 2170} 2171 2172/* Check to see if the symbol is defined in BLOCK or its superiors. 2173 Don't search STATIC_BLOCK or GLOBAL_BLOCK. */ 2174 2175static struct block_symbol 2176lookup_local_symbol (const char *name, 2177 symbol_name_match_type match_type, 2178 const struct block *block, 2179 const domain_enum domain, 2180 enum language language) 2181{ 2182 struct symbol *sym; 2183 const struct block *static_block = block_static_block (block); 2184 const char *scope = block_scope (block); 2185 2186 /* Check if either no block is specified or it's a global block. */ 2187 2188 if (static_block == NULL) 2189 return {}; 2190 2191 while (block != static_block) 2192 { 2193 sym = lookup_symbol_in_block (name, match_type, block, domain); 2194 if (sym != NULL) 2195 return (struct block_symbol) {sym, block}; 2196 2197 if (language == language_cplus || language == language_fortran) 2198 { 2199 struct block_symbol blocksym 2200 = cp_lookup_symbol_imports_or_template (scope, name, block, 2201 domain); 2202 2203 if (blocksym.symbol != NULL) 2204 return blocksym; 2205 } 2206 2207 if (block->function () != NULL && block_inlined_p (block)) 2208 break; 2209 block = block->superblock (); 2210 } 2211 2212 /* We've reached the end of the function without finding a result. */ 2213 2214 return {}; 2215} 2216 2217/* See symtab.h. */ 2218 2219struct symbol * 2220lookup_symbol_in_block (const char *name, symbol_name_match_type match_type, 2221 const struct block *block, 2222 const domain_enum domain) 2223{ 2224 struct symbol *sym; 2225 2226 if (symbol_lookup_debug) 2227 { 2228 struct objfile *objfile 2229 = block == nullptr ? nullptr : block_objfile (block); 2230 2231 symbol_lookup_debug_printf_v 2232 ("lookup_symbol_in_block (%s, %s (objfile %s), %s)", 2233 name, host_address_to_string (block), 2234 objfile != nullptr ? objfile_debug_name (objfile) : "NULL", 2235 domain_name (domain)); 2236 } 2237 2238 sym = block_lookup_symbol (block, name, match_type, domain); 2239 if (sym) 2240 { 2241 symbol_lookup_debug_printf_v ("lookup_symbol_in_block (...) = %s", 2242 host_address_to_string (sym)); 2243 return fixup_symbol_section (sym, NULL); 2244 } 2245 2246 symbol_lookup_debug_printf_v ("lookup_symbol_in_block (...) = NULL"); 2247 return NULL; 2248} 2249 2250/* See symtab.h. */ 2251 2252struct block_symbol 2253lookup_global_symbol_from_objfile (struct objfile *main_objfile, 2254 enum block_enum block_index, 2255 const char *name, 2256 const domain_enum domain) 2257{ 2258 gdb_assert (block_index == GLOBAL_BLOCK || block_index == STATIC_BLOCK); 2259 2260 for (objfile *objfile : main_objfile->separate_debug_objfiles ()) 2261 { 2262 struct block_symbol result 2263 = lookup_symbol_in_objfile (objfile, block_index, name, domain); 2264 2265 if (result.symbol != nullptr) 2266 return result; 2267 } 2268 2269 return {}; 2270} 2271 2272/* Check to see if the symbol is defined in one of the OBJFILE's 2273 symtabs. BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK, 2274 depending on whether or not we want to search global symbols or 2275 static symbols. */ 2276 2277static struct block_symbol 2278lookup_symbol_in_objfile_symtabs (struct objfile *objfile, 2279 enum block_enum block_index, const char *name, 2280 const domain_enum domain) 2281{ 2282 gdb_assert (block_index == GLOBAL_BLOCK || block_index == STATIC_BLOCK); 2283 2284 symbol_lookup_debug_printf_v 2285 ("lookup_symbol_in_objfile_symtabs (%s, %s, %s, %s)", 2286 objfile_debug_name (objfile), 2287 block_index == GLOBAL_BLOCK ? "GLOBAL_BLOCK" : "STATIC_BLOCK", 2288 name, domain_name (domain)); 2289 2290 struct block_symbol other; 2291 other.symbol = NULL; 2292 for (compunit_symtab *cust : objfile->compunits ()) 2293 { 2294 const struct blockvector *bv; 2295 const struct block *block; 2296 struct block_symbol result; 2297 2298 bv = cust->blockvector (); 2299 block = bv->block (block_index); 2300 result.symbol = block_lookup_symbol_primary (block, name, domain); 2301 result.block = block; 2302 if (result.symbol == NULL) 2303 continue; 2304 if (best_symbol (result.symbol, domain)) 2305 { 2306 other = result; 2307 break; 2308 } 2309 if (symbol_matches_domain (result.symbol->language (), 2310 result.symbol->domain (), domain)) 2311 { 2312 struct symbol *better 2313 = better_symbol (other.symbol, result.symbol, domain); 2314 if (better != other.symbol) 2315 { 2316 other.symbol = better; 2317 other.block = block; 2318 } 2319 } 2320 } 2321 2322 if (other.symbol != NULL) 2323 { 2324 symbol_lookup_debug_printf_v 2325 ("lookup_symbol_in_objfile_symtabs (...) = %s (block %s)", 2326 host_address_to_string (other.symbol), 2327 host_address_to_string (other.block)); 2328 other.symbol = fixup_symbol_section (other.symbol, objfile); 2329 return other; 2330 } 2331 2332 symbol_lookup_debug_printf_v 2333 ("lookup_symbol_in_objfile_symtabs (...) = NULL"); 2334 return {}; 2335} 2336 2337/* Wrapper around lookup_symbol_in_objfile_symtabs for search_symbols. 2338 Look up LINKAGE_NAME in DOMAIN in the global and static blocks of OBJFILE 2339 and all associated separate debug objfiles. 2340 2341 Normally we only look in OBJFILE, and not any separate debug objfiles 2342 because the outer loop will cause them to be searched too. This case is 2343 different. Here we're called from search_symbols where it will only 2344 call us for the objfile that contains a matching minsym. */ 2345 2346static struct block_symbol 2347lookup_symbol_in_objfile_from_linkage_name (struct objfile *objfile, 2348 const char *linkage_name, 2349 domain_enum domain) 2350{ 2351 enum language lang = current_language->la_language; 2352 struct objfile *main_objfile; 2353 2354 demangle_result_storage storage; 2355 const char *modified_name = demangle_for_lookup (linkage_name, lang, storage); 2356 2357 if (objfile->separate_debug_objfile_backlink) 2358 main_objfile = objfile->separate_debug_objfile_backlink; 2359 else 2360 main_objfile = objfile; 2361 2362 for (::objfile *cur_objfile : main_objfile->separate_debug_objfiles ()) 2363 { 2364 struct block_symbol result; 2365 2366 result = lookup_symbol_in_objfile_symtabs (cur_objfile, GLOBAL_BLOCK, 2367 modified_name, domain); 2368 if (result.symbol == NULL) 2369 result = lookup_symbol_in_objfile_symtabs (cur_objfile, STATIC_BLOCK, 2370 modified_name, domain); 2371 if (result.symbol != NULL) 2372 return result; 2373 } 2374 2375 return {}; 2376} 2377 2378/* A helper function that throws an exception when a symbol was found 2379 in a psymtab but not in a symtab. */ 2380 2381static void ATTRIBUTE_NORETURN 2382error_in_psymtab_expansion (enum block_enum block_index, const char *name, 2383 struct compunit_symtab *cust) 2384{ 2385 error (_("\ 2386Internal: %s symbol `%s' found in %s psymtab but not in symtab.\n\ 2387%s may be an inlined function, or may be a template function\n \ 2388(if a template, try specifying an instantiation: %s<type>)."), 2389 block_index == GLOBAL_BLOCK ? "global" : "static", 2390 name, 2391 symtab_to_filename_for_display (cust->primary_filetab ()), 2392 name, name); 2393} 2394 2395/* A helper function for various lookup routines that interfaces with 2396 the "quick" symbol table functions. */ 2397 2398static struct block_symbol 2399lookup_symbol_via_quick_fns (struct objfile *objfile, 2400 enum block_enum block_index, const char *name, 2401 const domain_enum domain) 2402{ 2403 struct compunit_symtab *cust; 2404 const struct blockvector *bv; 2405 const struct block *block; 2406 struct block_symbol result; 2407 2408 symbol_lookup_debug_printf_v 2409 ("lookup_symbol_via_quick_fns (%s, %s, %s, %s)", 2410 objfile_debug_name (objfile), 2411 block_index == GLOBAL_BLOCK ? "GLOBAL_BLOCK" : "STATIC_BLOCK", 2412 name, domain_name (domain)); 2413 2414 cust = objfile->lookup_symbol (block_index, name, domain); 2415 if (cust == NULL) 2416 { 2417 symbol_lookup_debug_printf_v 2418 ("lookup_symbol_via_quick_fns (...) = NULL"); 2419 return {}; 2420 } 2421 2422 bv = cust->blockvector (); 2423 block = bv->block (block_index); 2424 result.symbol = block_lookup_symbol (block, name, 2425 symbol_name_match_type::FULL, domain); 2426 if (result.symbol == NULL) 2427 error_in_psymtab_expansion (block_index, name, cust); 2428 2429 symbol_lookup_debug_printf_v 2430 ("lookup_symbol_via_quick_fns (...) = %s (block %s)", 2431 host_address_to_string (result.symbol), 2432 host_address_to_string (block)); 2433 2434 result.symbol = fixup_symbol_section (result.symbol, objfile); 2435 result.block = block; 2436 return result; 2437} 2438 2439/* See language.h. */ 2440 2441struct block_symbol 2442language_defn::lookup_symbol_nonlocal (const char *name, 2443 const struct block *block, 2444 const domain_enum domain) const 2445{ 2446 struct block_symbol result; 2447 2448 /* NOTE: dje/2014-10-26: The lookup in all objfiles search could skip 2449 the current objfile. Searching the current objfile first is useful 2450 for both matching user expectations as well as performance. */ 2451 2452 result = lookup_symbol_in_static_block (name, block, domain); 2453 if (result.symbol != NULL) 2454 return result; 2455 2456 /* If we didn't find a definition for a builtin type in the static block, 2457 search for it now. This is actually the right thing to do and can be 2458 a massive performance win. E.g., when debugging a program with lots of 2459 shared libraries we could search all of them only to find out the 2460 builtin type isn't defined in any of them. This is common for types 2461 like "void". */ 2462 if (domain == VAR_DOMAIN) 2463 { 2464 struct gdbarch *gdbarch; 2465 2466 if (block == NULL) 2467 gdbarch = target_gdbarch (); 2468 else 2469 gdbarch = block_gdbarch (block); 2470 result.symbol = language_lookup_primitive_type_as_symbol (this, 2471 gdbarch, name); 2472 result.block = NULL; 2473 if (result.symbol != NULL) 2474 return result; 2475 } 2476 2477 return lookup_global_symbol (name, block, domain); 2478} 2479 2480/* See symtab.h. */ 2481 2482struct block_symbol 2483lookup_symbol_in_static_block (const char *name, 2484 const struct block *block, 2485 const domain_enum domain) 2486{ 2487 const struct block *static_block = block_static_block (block); 2488 struct symbol *sym; 2489 2490 if (static_block == NULL) 2491 return {}; 2492 2493 if (symbol_lookup_debug) 2494 { 2495 struct objfile *objfile = (block == nullptr 2496 ? nullptr : block_objfile (block)); 2497 2498 symbol_lookup_debug_printf 2499 ("lookup_symbol_in_static_block (%s, %s (objfile %s), %s)", 2500 name, host_address_to_string (block), 2501 objfile != nullptr ? objfile_debug_name (objfile) : "NULL", 2502 domain_name (domain)); 2503 } 2504 2505 sym = lookup_symbol_in_block (name, 2506 symbol_name_match_type::FULL, 2507 static_block, domain); 2508 symbol_lookup_debug_printf ("lookup_symbol_in_static_block (...) = %s", 2509 sym != NULL 2510 ? host_address_to_string (sym) : "NULL"); 2511 return (struct block_symbol) {sym, static_block}; 2512} 2513 2514/* Perform the standard symbol lookup of NAME in OBJFILE: 2515 1) First search expanded symtabs, and if not found 2516 2) Search the "quick" symtabs (partial or .gdb_index). 2517 BLOCK_INDEX is one of GLOBAL_BLOCK or STATIC_BLOCK. */ 2518 2519static struct block_symbol 2520lookup_symbol_in_objfile (struct objfile *objfile, enum block_enum block_index, 2521 const char *name, const domain_enum domain) 2522{ 2523 struct block_symbol result; 2524 2525 gdb_assert (block_index == GLOBAL_BLOCK || block_index == STATIC_BLOCK); 2526 2527 symbol_lookup_debug_printf ("lookup_symbol_in_objfile (%s, %s, %s, %s)", 2528 objfile_debug_name (objfile), 2529 block_index == GLOBAL_BLOCK 2530 ? "GLOBAL_BLOCK" : "STATIC_BLOCK", 2531 name, domain_name (domain)); 2532 2533 result = lookup_symbol_in_objfile_symtabs (objfile, block_index, 2534 name, domain); 2535 if (result.symbol != NULL) 2536 { 2537 symbol_lookup_debug_printf 2538 ("lookup_symbol_in_objfile (...) = %s (in symtabs)", 2539 host_address_to_string (result.symbol)); 2540 return result; 2541 } 2542 2543 result = lookup_symbol_via_quick_fns (objfile, block_index, 2544 name, domain); 2545 symbol_lookup_debug_printf ("lookup_symbol_in_objfile (...) = %s%s", 2546 result.symbol != NULL 2547 ? host_address_to_string (result.symbol) 2548 : "NULL", 2549 result.symbol != NULL ? " (via quick fns)" 2550 : ""); 2551 return result; 2552} 2553 2554/* This function contains the common code of lookup_{global,static}_symbol. 2555 OBJFILE is only used if BLOCK_INDEX is GLOBAL_SCOPE, in which case it is 2556 the objfile to start the lookup in. */ 2557 2558static struct block_symbol 2559lookup_global_or_static_symbol (const char *name, 2560 enum block_enum block_index, 2561 struct objfile *objfile, 2562 const domain_enum domain) 2563{ 2564 struct symbol_cache *cache = get_symbol_cache (current_program_space); 2565 struct block_symbol result; 2566 struct block_symbol_cache *bsc; 2567 struct symbol_cache_slot *slot; 2568 2569 gdb_assert (block_index == GLOBAL_BLOCK || block_index == STATIC_BLOCK); 2570 gdb_assert (objfile == nullptr || block_index == GLOBAL_BLOCK); 2571 2572 /* First see if we can find the symbol in the cache. 2573 This works because we use the current objfile to qualify the lookup. */ 2574 result = symbol_cache_lookup (cache, objfile, block_index, name, domain, 2575 &bsc, &slot); 2576 if (result.symbol != NULL) 2577 { 2578 if (SYMBOL_LOOKUP_FAILED_P (result)) 2579 return {}; 2580 return result; 2581 } 2582 2583 /* Do a global search (of global blocks, heh). */ 2584 if (result.symbol == NULL) 2585 gdbarch_iterate_over_objfiles_in_search_order 2586 (objfile != NULL ? objfile->arch () : target_gdbarch (), 2587 [&result, block_index, name, domain] (struct objfile *objfile_iter) 2588 { 2589 result = lookup_symbol_in_objfile (objfile_iter, block_index, 2590 name, domain); 2591 return result.symbol != nullptr; 2592 }, 2593 objfile); 2594 2595 if (result.symbol != NULL) 2596 symbol_cache_mark_found (bsc, slot, objfile, result.symbol, result.block); 2597 else 2598 symbol_cache_mark_not_found (bsc, slot, objfile, name, domain); 2599 2600 return result; 2601} 2602 2603/* See symtab.h. */ 2604 2605struct block_symbol 2606lookup_static_symbol (const char *name, const domain_enum domain) 2607{ 2608 return lookup_global_or_static_symbol (name, STATIC_BLOCK, nullptr, domain); 2609} 2610 2611/* See symtab.h. */ 2612 2613struct block_symbol 2614lookup_global_symbol (const char *name, 2615 const struct block *block, 2616 const domain_enum domain) 2617{ 2618 /* If a block was passed in, we want to search the corresponding 2619 global block first. This yields "more expected" behavior, and is 2620 needed to support 'FILENAME'::VARIABLE lookups. */ 2621 const struct block *global_block = block_global_block (block); 2622 symbol *sym = NULL; 2623 if (global_block != nullptr) 2624 { 2625 sym = lookup_symbol_in_block (name, 2626 symbol_name_match_type::FULL, 2627 global_block, domain); 2628 if (sym != NULL && best_symbol (sym, domain)) 2629 return { sym, global_block }; 2630 } 2631 2632 struct objfile *objfile = nullptr; 2633 if (block != nullptr) 2634 { 2635 objfile = block_objfile (block); 2636 if (objfile->separate_debug_objfile_backlink != nullptr) 2637 objfile = objfile->separate_debug_objfile_backlink; 2638 } 2639 2640 block_symbol bs 2641 = lookup_global_or_static_symbol (name, GLOBAL_BLOCK, objfile, domain); 2642 if (better_symbol (sym, bs.symbol, domain) == sym) 2643 return { sym, global_block }; 2644 else 2645 return bs; 2646} 2647 2648bool 2649symbol_matches_domain (enum language symbol_language, 2650 domain_enum symbol_domain, 2651 domain_enum domain) 2652{ 2653 /* For C++ "struct foo { ... }" also defines a typedef for "foo". 2654 Similarly, any Ada type declaration implicitly defines a typedef. */ 2655 if (symbol_language == language_cplus 2656 || symbol_language == language_d 2657 || symbol_language == language_ada 2658 || symbol_language == language_rust) 2659 { 2660 if ((domain == VAR_DOMAIN || domain == STRUCT_DOMAIN) 2661 && symbol_domain == STRUCT_DOMAIN) 2662 return true; 2663 } 2664 /* For all other languages, strict match is required. */ 2665 return (symbol_domain == domain); 2666} 2667 2668/* See symtab.h. */ 2669 2670struct type * 2671lookup_transparent_type (const char *name) 2672{ 2673 return current_language->lookup_transparent_type (name); 2674} 2675 2676/* A helper for basic_lookup_transparent_type that interfaces with the 2677 "quick" symbol table functions. */ 2678 2679static struct type * 2680basic_lookup_transparent_type_quick (struct objfile *objfile, 2681 enum block_enum block_index, 2682 const char *name) 2683{ 2684 struct compunit_symtab *cust; 2685 const struct blockvector *bv; 2686 const struct block *block; 2687 struct symbol *sym; 2688 2689 cust = objfile->lookup_symbol (block_index, name, STRUCT_DOMAIN); 2690 if (cust == NULL) 2691 return NULL; 2692 2693 bv = cust->blockvector (); 2694 block = bv->block (block_index); 2695 sym = block_find_symbol (block, name, STRUCT_DOMAIN, 2696 block_find_non_opaque_type, NULL); 2697 if (sym == NULL) 2698 error_in_psymtab_expansion (block_index, name, cust); 2699 gdb_assert (!TYPE_IS_OPAQUE (sym->type ())); 2700 return sym->type (); 2701} 2702 2703/* Subroutine of basic_lookup_transparent_type to simplify it. 2704 Look up the non-opaque definition of NAME in BLOCK_INDEX of OBJFILE. 2705 BLOCK_INDEX is either GLOBAL_BLOCK or STATIC_BLOCK. */ 2706 2707static struct type * 2708basic_lookup_transparent_type_1 (struct objfile *objfile, 2709 enum block_enum block_index, 2710 const char *name) 2711{ 2712 const struct blockvector *bv; 2713 const struct block *block; 2714 const struct symbol *sym; 2715 2716 for (compunit_symtab *cust : objfile->compunits ()) 2717 { 2718 bv = cust->blockvector (); 2719 block = bv->block (block_index); 2720 sym = block_find_symbol (block, name, STRUCT_DOMAIN, 2721 block_find_non_opaque_type, NULL); 2722 if (sym != NULL) 2723 { 2724 gdb_assert (!TYPE_IS_OPAQUE (sym->type ())); 2725 return sym->type (); 2726 } 2727 } 2728 2729 return NULL; 2730} 2731 2732/* The standard implementation of lookup_transparent_type. This code 2733 was modeled on lookup_symbol -- the parts not relevant to looking 2734 up types were just left out. In particular it's assumed here that 2735 types are available in STRUCT_DOMAIN and only in file-static or 2736 global blocks. */ 2737 2738struct type * 2739basic_lookup_transparent_type (const char *name) 2740{ 2741 struct type *t; 2742 2743 /* Now search all the global symbols. Do the symtab's first, then 2744 check the psymtab's. If a psymtab indicates the existence 2745 of the desired name as a global, then do psymtab-to-symtab 2746 conversion on the fly and return the found symbol. */ 2747 2748 for (objfile *objfile : current_program_space->objfiles ()) 2749 { 2750 t = basic_lookup_transparent_type_1 (objfile, GLOBAL_BLOCK, name); 2751 if (t) 2752 return t; 2753 } 2754 2755 for (objfile *objfile : current_program_space->objfiles ()) 2756 { 2757 t = basic_lookup_transparent_type_quick (objfile, GLOBAL_BLOCK, name); 2758 if (t) 2759 return t; 2760 } 2761 2762 /* Now search the static file-level symbols. 2763 Not strictly correct, but more useful than an error. 2764 Do the symtab's first, then 2765 check the psymtab's. If a psymtab indicates the existence 2766 of the desired name as a file-level static, then do psymtab-to-symtab 2767 conversion on the fly and return the found symbol. */ 2768 2769 for (objfile *objfile : current_program_space->objfiles ()) 2770 { 2771 t = basic_lookup_transparent_type_1 (objfile, STATIC_BLOCK, name); 2772 if (t) 2773 return t; 2774 } 2775 2776 for (objfile *objfile : current_program_space->objfiles ()) 2777 { 2778 t = basic_lookup_transparent_type_quick (objfile, STATIC_BLOCK, name); 2779 if (t) 2780 return t; 2781 } 2782 2783 return (struct type *) 0; 2784} 2785 2786/* See symtab.h. */ 2787 2788bool 2789iterate_over_symbols (const struct block *block, 2790 const lookup_name_info &name, 2791 const domain_enum domain, 2792 gdb::function_view<symbol_found_callback_ftype> callback) 2793{ 2794 struct block_iterator iter; 2795 struct symbol *sym; 2796 2797 ALL_BLOCK_SYMBOLS_WITH_NAME (block, name, iter, sym) 2798 { 2799 if (symbol_matches_domain (sym->language (), sym->domain (), domain)) 2800 { 2801 struct block_symbol block_sym = {sym, block}; 2802 2803 if (!callback (&block_sym)) 2804 return false; 2805 } 2806 } 2807 return true; 2808} 2809 2810/* See symtab.h. */ 2811 2812bool 2813iterate_over_symbols_terminated 2814 (const struct block *block, 2815 const lookup_name_info &name, 2816 const domain_enum domain, 2817 gdb::function_view<symbol_found_callback_ftype> callback) 2818{ 2819 if (!iterate_over_symbols (block, name, domain, callback)) 2820 return false; 2821 struct block_symbol block_sym = {nullptr, block}; 2822 return callback (&block_sym); 2823} 2824 2825/* Find the compunit symtab associated with PC and SECTION. 2826 This will read in debug info as necessary. */ 2827 2828struct compunit_symtab * 2829find_pc_sect_compunit_symtab (CORE_ADDR pc, struct obj_section *section) 2830{ 2831 struct compunit_symtab *best_cust = NULL; 2832 CORE_ADDR best_cust_range = 0; 2833 struct bound_minimal_symbol msymbol; 2834 2835 /* If we know that this is not a text address, return failure. This is 2836 necessary because we loop based on the block's high and low code 2837 addresses, which do not include the data ranges, and because 2838 we call find_pc_sect_psymtab which has a similar restriction based 2839 on the partial_symtab's texthigh and textlow. */ 2840 msymbol = lookup_minimal_symbol_by_pc_section (pc, section); 2841 if (msymbol.minsym && msymbol.minsym->data_p ()) 2842 return NULL; 2843 2844 /* Search all symtabs for the one whose file contains our address, and which 2845 is the smallest of all the ones containing the address. This is designed 2846 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000 2847 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from 2848 0x1000-0x4000, but for address 0x2345 we want to return symtab b. 2849 2850 This happens for native ecoff format, where code from included files 2851 gets its own symtab. The symtab for the included file should have 2852 been read in already via the dependency mechanism. 2853 It might be swifter to create several symtabs with the same name 2854 like xcoff does (I'm not sure). 2855 2856 It also happens for objfiles that have their functions reordered. 2857 For these, the symtab we are looking for is not necessarily read in. */ 2858 2859 for (objfile *obj_file : current_program_space->objfiles ()) 2860 { 2861 for (compunit_symtab *cust : obj_file->compunits ()) 2862 { 2863 const struct blockvector *bv = cust->blockvector (); 2864 const struct block *global_block = bv->global_block (); 2865 CORE_ADDR start = global_block->start (); 2866 CORE_ADDR end = global_block->end (); 2867 bool in_range_p = start <= pc && pc < end; 2868 if (!in_range_p) 2869 continue; 2870 2871 if (bv->map () != nullptr) 2872 { 2873 if (bv->map ()->find (pc) == nullptr) 2874 continue; 2875 2876 return cust; 2877 } 2878 2879 CORE_ADDR range = end - start; 2880 if (best_cust != nullptr 2881 && range >= best_cust_range) 2882 /* Cust doesn't have a smaller range than best_cust, skip it. */ 2883 continue; 2884 2885 /* For an objfile that has its functions reordered, 2886 find_pc_psymtab will find the proper partial symbol table 2887 and we simply return its corresponding symtab. */ 2888 /* In order to better support objfiles that contain both 2889 stabs and coff debugging info, we continue on if a psymtab 2890 can't be found. */ 2891 if ((obj_file->flags & OBJF_REORDERED) != 0) 2892 { 2893 struct compunit_symtab *result; 2894 2895 result 2896 = obj_file->find_pc_sect_compunit_symtab (msymbol, 2897 pc, 2898 section, 2899 0); 2900 if (result != NULL) 2901 return result; 2902 } 2903 2904 if (section != 0) 2905 { 2906 struct symbol *sym = NULL; 2907 struct block_iterator iter; 2908 2909 for (int b_index = GLOBAL_BLOCK; 2910 b_index <= STATIC_BLOCK && sym == NULL; 2911 ++b_index) 2912 { 2913 const struct block *b = bv->block (b_index); 2914 ALL_BLOCK_SYMBOLS (b, iter, sym) 2915 { 2916 fixup_symbol_section (sym, obj_file); 2917 if (matching_obj_sections (sym->obj_section (obj_file), 2918 section)) 2919 break; 2920 } 2921 } 2922 if (sym == NULL) 2923 continue; /* No symbol in this symtab matches 2924 section. */ 2925 } 2926 2927 /* Cust is best found sofar, save it. */ 2928 best_cust = cust; 2929 best_cust_range = range; 2930 } 2931 } 2932 2933 if (best_cust != NULL) 2934 return best_cust; 2935 2936 /* Not found in symtabs, search the "quick" symtabs (e.g. psymtabs). */ 2937 2938 for (objfile *objf : current_program_space->objfiles ()) 2939 { 2940 struct compunit_symtab *result 2941 = objf->find_pc_sect_compunit_symtab (msymbol, pc, section, 1); 2942 if (result != NULL) 2943 return result; 2944 } 2945 2946 return NULL; 2947} 2948 2949/* Find the compunit symtab associated with PC. 2950 This will read in debug info as necessary. 2951 Backward compatibility, no section. */ 2952 2953struct compunit_symtab * 2954find_pc_compunit_symtab (CORE_ADDR pc) 2955{ 2956 return find_pc_sect_compunit_symtab (pc, find_pc_mapped_section (pc)); 2957} 2958 2959/* See symtab.h. */ 2960 2961struct symbol * 2962find_symbol_at_address (CORE_ADDR address) 2963{ 2964 /* A helper function to search a given symtab for a symbol matching 2965 ADDR. */ 2966 auto search_symtab = [] (compunit_symtab *symtab, CORE_ADDR addr) -> symbol * 2967 { 2968 const struct blockvector *bv = symtab->blockvector (); 2969 2970 for (int i = GLOBAL_BLOCK; i <= STATIC_BLOCK; ++i) 2971 { 2972 const struct block *b = bv->block (i); 2973 struct block_iterator iter; 2974 struct symbol *sym; 2975 2976 ALL_BLOCK_SYMBOLS (b, iter, sym) 2977 { 2978 if (sym->aclass () == LOC_STATIC 2979 && sym->value_address () == addr) 2980 return sym; 2981 } 2982 } 2983 return nullptr; 2984 }; 2985 2986 for (objfile *objfile : current_program_space->objfiles ()) 2987 { 2988 /* If this objfile was read with -readnow, then we need to 2989 search the symtabs directly. */ 2990 if ((objfile->flags & OBJF_READNOW) != 0) 2991 { 2992 for (compunit_symtab *symtab : objfile->compunits ()) 2993 { 2994 struct symbol *sym = search_symtab (symtab, address); 2995 if (sym != nullptr) 2996 return sym; 2997 } 2998 } 2999 else 3000 { 3001 struct compunit_symtab *symtab 3002 = objfile->find_compunit_symtab_by_address (address); 3003 if (symtab != NULL) 3004 { 3005 struct symbol *sym = search_symtab (symtab, address); 3006 if (sym != nullptr) 3007 return sym; 3008 } 3009 } 3010 } 3011 3012 return NULL; 3013} 3014 3015 3016 3017/* Find the source file and line number for a given PC value and SECTION. 3018 Return a structure containing a symtab pointer, a line number, 3019 and a pc range for the entire source line. 3020 The value's .pc field is NOT the specified pc. 3021 NOTCURRENT nonzero means, if specified pc is on a line boundary, 3022 use the line that ends there. Otherwise, in that case, the line 3023 that begins there is used. */ 3024 3025/* The big complication here is that a line may start in one file, and end just 3026 before the start of another file. This usually occurs when you #include 3027 code in the middle of a subroutine. To properly find the end of a line's PC 3028 range, we must search all symtabs associated with this compilation unit, and 3029 find the one whose first PC is closer than that of the next line in this 3030 symtab. */ 3031 3032struct symtab_and_line 3033find_pc_sect_line (CORE_ADDR pc, struct obj_section *section, int notcurrent) 3034{ 3035 struct compunit_symtab *cust; 3036 struct linetable *l; 3037 int len; 3038 struct linetable_entry *item; 3039 const struct blockvector *bv; 3040 struct bound_minimal_symbol msymbol; 3041 3042 /* Info on best line seen so far, and where it starts, and its file. */ 3043 3044 struct linetable_entry *best = NULL; 3045 CORE_ADDR best_end = 0; 3046 struct symtab *best_symtab = 0; 3047 3048 /* Store here the first line number 3049 of a file which contains the line at the smallest pc after PC. 3050 If we don't find a line whose range contains PC, 3051 we will use a line one less than this, 3052 with a range from the start of that file to the first line's pc. */ 3053 struct linetable_entry *alt = NULL; 3054 3055 /* Info on best line seen in this file. */ 3056 3057 struct linetable_entry *prev; 3058 3059 /* If this pc is not from the current frame, 3060 it is the address of the end of a call instruction. 3061 Quite likely that is the start of the following statement. 3062 But what we want is the statement containing the instruction. 3063 Fudge the pc to make sure we get that. */ 3064 3065 /* It's tempting to assume that, if we can't find debugging info for 3066 any function enclosing PC, that we shouldn't search for line 3067 number info, either. However, GAS can emit line number info for 3068 assembly files --- very helpful when debugging hand-written 3069 assembly code. In such a case, we'd have no debug info for the 3070 function, but we would have line info. */ 3071 3072 if (notcurrent) 3073 pc -= 1; 3074 3075 /* elz: added this because this function returned the wrong 3076 information if the pc belongs to a stub (import/export) 3077 to call a shlib function. This stub would be anywhere between 3078 two functions in the target, and the line info was erroneously 3079 taken to be the one of the line before the pc. */ 3080 3081 /* RT: Further explanation: 3082 3083 * We have stubs (trampolines) inserted between procedures. 3084 * 3085 * Example: "shr1" exists in a shared library, and a "shr1" stub also 3086 * exists in the main image. 3087 * 3088 * In the minimal symbol table, we have a bunch of symbols 3089 * sorted by start address. The stubs are marked as "trampoline", 3090 * the others appear as text. E.g.: 3091 * 3092 * Minimal symbol table for main image 3093 * main: code for main (text symbol) 3094 * shr1: stub (trampoline symbol) 3095 * foo: code for foo (text symbol) 3096 * ... 3097 * Minimal symbol table for "shr1" image: 3098 * ... 3099 * shr1: code for shr1 (text symbol) 3100 * ... 3101 * 3102 * So the code below is trying to detect if we are in the stub 3103 * ("shr1" stub), and if so, find the real code ("shr1" trampoline), 3104 * and if found, do the symbolization from the real-code address 3105 * rather than the stub address. 3106 * 3107 * Assumptions being made about the minimal symbol table: 3108 * 1. lookup_minimal_symbol_by_pc() will return a trampoline only 3109 * if we're really in the trampoline.s If we're beyond it (say 3110 * we're in "foo" in the above example), it'll have a closer 3111 * symbol (the "foo" text symbol for example) and will not 3112 * return the trampoline. 3113 * 2. lookup_minimal_symbol_text() will find a real text symbol 3114 * corresponding to the trampoline, and whose address will 3115 * be different than the trampoline address. I put in a sanity 3116 * check for the address being the same, to avoid an 3117 * infinite recursion. 3118 */ 3119 msymbol = lookup_minimal_symbol_by_pc (pc); 3120 if (msymbol.minsym != NULL) 3121 if (msymbol.minsym->type () == mst_solib_trampoline) 3122 { 3123 struct bound_minimal_symbol mfunsym 3124 = lookup_minimal_symbol_text (msymbol.minsym->linkage_name (), 3125 NULL); 3126 3127 if (mfunsym.minsym == NULL) 3128 /* I eliminated this warning since it is coming out 3129 * in the following situation: 3130 * gdb shmain // test program with shared libraries 3131 * (gdb) break shr1 // function in shared lib 3132 * Warning: In stub for ... 3133 * In the above situation, the shared lib is not loaded yet, 3134 * so of course we can't find the real func/line info, 3135 * but the "break" still works, and the warning is annoying. 3136 * So I commented out the warning. RT */ 3137 /* warning ("In stub for %s; unable to find real function/line info", 3138 msymbol->linkage_name ()); */ 3139 ; 3140 /* fall through */ 3141 else if (mfunsym.value_address () 3142 == msymbol.value_address ()) 3143 /* Avoid infinite recursion */ 3144 /* See above comment about why warning is commented out. */ 3145 /* warning ("In stub for %s; unable to find real function/line info", 3146 msymbol->linkage_name ()); */ 3147 ; 3148 /* fall through */ 3149 else 3150 { 3151 /* Detect an obvious case of infinite recursion. If this 3152 should occur, we'd like to know about it, so error out, 3153 fatally. */ 3154 if (mfunsym.value_address () == pc) 3155 internal_error (_("Infinite recursion detected in find_pc_sect_line;" 3156 "please file a bug report")); 3157 3158 return find_pc_line (mfunsym.value_address (), 0); 3159 } 3160 } 3161 3162 symtab_and_line val; 3163 val.pspace = current_program_space; 3164 3165 cust = find_pc_sect_compunit_symtab (pc, section); 3166 if (cust == NULL) 3167 { 3168 /* If no symbol information, return previous pc. */ 3169 if (notcurrent) 3170 pc++; 3171 val.pc = pc; 3172 return val; 3173 } 3174 3175 bv = cust->blockvector (); 3176 3177 /* Look at all the symtabs that share this blockvector. 3178 They all have the same apriori range, that we found was right; 3179 but they have different line tables. */ 3180 3181 for (symtab *iter_s : cust->filetabs ()) 3182 { 3183 /* Find the best line in this symtab. */ 3184 l = iter_s->linetable (); 3185 if (!l) 3186 continue; 3187 len = l->nitems; 3188 if (len <= 0) 3189 { 3190 /* I think len can be zero if the symtab lacks line numbers 3191 (e.g. gcc -g1). (Either that or the LINETABLE is NULL; 3192 I'm not sure which, and maybe it depends on the symbol 3193 reader). */ 3194 continue; 3195 } 3196 3197 prev = NULL; 3198 item = l->item; /* Get first line info. */ 3199 3200 /* Is this file's first line closer than the first lines of other files? 3201 If so, record this file, and its first line, as best alternate. */ 3202 if (item->pc > pc && (!alt || item->pc < alt->pc)) 3203 alt = item; 3204 3205 auto pc_compare = [](const CORE_ADDR & comp_pc, 3206 const struct linetable_entry & lhs)->bool 3207 { 3208 return comp_pc < lhs.pc; 3209 }; 3210 3211 struct linetable_entry *first = item; 3212 struct linetable_entry *last = item + len; 3213 item = std::upper_bound (first, last, pc, pc_compare); 3214 if (item != first) 3215 prev = item - 1; /* Found a matching item. */ 3216 3217 /* At this point, prev points at the line whose start addr is <= pc, and 3218 item points at the next line. If we ran off the end of the linetable 3219 (pc >= start of the last line), then prev == item. If pc < start of 3220 the first line, prev will not be set. */ 3221 3222 /* Is this file's best line closer than the best in the other files? 3223 If so, record this file, and its best line, as best so far. Don't 3224 save prev if it represents the end of a function (i.e. line number 3225 0) instead of a real line. */ 3226 3227 if (prev && prev->line && (!best || prev->pc > best->pc)) 3228 { 3229 best = prev; 3230 best_symtab = iter_s; 3231 3232 /* If during the binary search we land on a non-statement entry, 3233 scan backward through entries at the same address to see if 3234 there is an entry marked as is-statement. In theory this 3235 duplication should have been removed from the line table 3236 during construction, this is just a double check. If the line 3237 table has had the duplication removed then this should be 3238 pretty cheap. */ 3239 if (!best->is_stmt) 3240 { 3241 struct linetable_entry *tmp = best; 3242 while (tmp > first && (tmp - 1)->pc == tmp->pc 3243 && (tmp - 1)->line != 0 && !tmp->is_stmt) 3244 --tmp; 3245 if (tmp->is_stmt) 3246 best = tmp; 3247 } 3248 3249 /* Discard BEST_END if it's before the PC of the current BEST. */ 3250 if (best_end <= best->pc) 3251 best_end = 0; 3252 } 3253 3254 /* If another line (denoted by ITEM) is in the linetable and its 3255 PC is after BEST's PC, but before the current BEST_END, then 3256 use ITEM's PC as the new best_end. */ 3257 if (best && item < last && item->pc > best->pc 3258 && (best_end == 0 || best_end > item->pc)) 3259 best_end = item->pc; 3260 } 3261 3262 if (!best_symtab) 3263 { 3264 /* If we didn't find any line number info, just return zeros. 3265 We used to return alt->line - 1 here, but that could be 3266 anywhere; if we don't have line number info for this PC, 3267 don't make some up. */ 3268 val.pc = pc; 3269 } 3270 else if (best->line == 0) 3271 { 3272 /* If our best fit is in a range of PC's for which no line 3273 number info is available (line number is zero) then we didn't 3274 find any valid line information. */ 3275 val.pc = pc; 3276 } 3277 else 3278 { 3279 val.is_stmt = best->is_stmt; 3280 val.symtab = best_symtab; 3281 val.line = best->line; 3282 val.pc = best->pc; 3283 if (best_end && (!alt || best_end < alt->pc)) 3284 val.end = best_end; 3285 else if (alt) 3286 val.end = alt->pc; 3287 else 3288 val.end = bv->global_block ()->end (); 3289 } 3290 val.section = section; 3291 return val; 3292} 3293 3294/* Backward compatibility (no section). */ 3295 3296struct symtab_and_line 3297find_pc_line (CORE_ADDR pc, int notcurrent) 3298{ 3299 struct obj_section *section; 3300 3301 section = find_pc_overlay (pc); 3302 if (!pc_in_unmapped_range (pc, section)) 3303 return find_pc_sect_line (pc, section, notcurrent); 3304 3305 /* If the original PC was an unmapped address then we translate this to a 3306 mapped address in order to lookup the sal. However, as the user 3307 passed us an unmapped address it makes more sense to return a result 3308 that has the pc and end fields translated to unmapped addresses. */ 3309 pc = overlay_mapped_address (pc, section); 3310 symtab_and_line sal = find_pc_sect_line (pc, section, notcurrent); 3311 sal.pc = overlay_unmapped_address (sal.pc, section); 3312 sal.end = overlay_unmapped_address (sal.end, section); 3313 return sal; 3314} 3315 3316/* See symtab.h. */ 3317 3318struct symtab * 3319find_pc_line_symtab (CORE_ADDR pc) 3320{ 3321 struct symtab_and_line sal; 3322 3323 /* This always passes zero for NOTCURRENT to find_pc_line. 3324 There are currently no callers that ever pass non-zero. */ 3325 sal = find_pc_line (pc, 0); 3326 return sal.symtab; 3327} 3328 3329/* Find line number LINE in any symtab whose name is the same as 3330 SYMTAB. 3331 3332 If found, return the symtab that contains the linetable in which it was 3333 found, set *INDEX to the index in the linetable of the best entry 3334 found, and set *EXACT_MATCH to true if the value returned is an 3335 exact match. 3336 3337 If not found, return NULL. */ 3338 3339struct symtab * 3340find_line_symtab (struct symtab *sym_tab, int line, 3341 int *index, bool *exact_match) 3342{ 3343 int exact = 0; /* Initialized here to avoid a compiler warning. */ 3344 3345 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE 3346 so far seen. */ 3347 3348 int best_index; 3349 struct linetable *best_linetable; 3350 struct symtab *best_symtab; 3351 3352 /* First try looking it up in the given symtab. */ 3353 best_linetable = sym_tab->linetable (); 3354 best_symtab = sym_tab; 3355 best_index = find_line_common (best_linetable, line, &exact, 0); 3356 if (best_index < 0 || !exact) 3357 { 3358 /* Didn't find an exact match. So we better keep looking for 3359 another symtab with the same name. In the case of xcoff, 3360 multiple csects for one source file (produced by IBM's FORTRAN 3361 compiler) produce multiple symtabs (this is unavoidable 3362 assuming csects can be at arbitrary places in memory and that 3363 the GLOBAL_BLOCK of a symtab has a begin and end address). */ 3364 3365 /* BEST is the smallest linenumber > LINE so far seen, 3366 or 0 if none has been seen so far. 3367 BEST_INDEX and BEST_LINETABLE identify the item for it. */ 3368 int best; 3369 3370 if (best_index >= 0) 3371 best = best_linetable->item[best_index].line; 3372 else 3373 best = 0; 3374 3375 for (objfile *objfile : current_program_space->objfiles ()) 3376 objfile->expand_symtabs_with_fullname (symtab_to_fullname (sym_tab)); 3377 3378 for (objfile *objfile : current_program_space->objfiles ()) 3379 { 3380 for (compunit_symtab *cu : objfile->compunits ()) 3381 { 3382 for (symtab *s : cu->filetabs ()) 3383 { 3384 struct linetable *l; 3385 int ind; 3386 3387 if (FILENAME_CMP (sym_tab->filename, s->filename) != 0) 3388 continue; 3389 if (FILENAME_CMP (symtab_to_fullname (sym_tab), 3390 symtab_to_fullname (s)) != 0) 3391 continue; 3392 l = s->linetable (); 3393 ind = find_line_common (l, line, &exact, 0); 3394 if (ind >= 0) 3395 { 3396 if (exact) 3397 { 3398 best_index = ind; 3399 best_linetable = l; 3400 best_symtab = s; 3401 goto done; 3402 } 3403 if (best == 0 || l->item[ind].line < best) 3404 { 3405 best = l->item[ind].line; 3406 best_index = ind; 3407 best_linetable = l; 3408 best_symtab = s; 3409 } 3410 } 3411 } 3412 } 3413 } 3414 } 3415done: 3416 if (best_index < 0) 3417 return NULL; 3418 3419 if (index) 3420 *index = best_index; 3421 if (exact_match) 3422 *exact_match = (exact != 0); 3423 3424 return best_symtab; 3425} 3426 3427/* Given SYMTAB, returns all the PCs function in the symtab that 3428 exactly match LINE. Returns an empty vector if there are no exact 3429 matches, but updates BEST_ITEM in this case. */ 3430 3431std::vector<CORE_ADDR> 3432find_pcs_for_symtab_line (struct symtab *symtab, int line, 3433 struct linetable_entry **best_item) 3434{ 3435 int start = 0; 3436 std::vector<CORE_ADDR> result; 3437 3438 /* First, collect all the PCs that are at this line. */ 3439 while (1) 3440 { 3441 int was_exact; 3442 int idx; 3443 3444 idx = find_line_common (symtab->linetable (), line, &was_exact, 3445 start); 3446 if (idx < 0) 3447 break; 3448 3449 if (!was_exact) 3450 { 3451 struct linetable_entry *item = &symtab->linetable ()->item[idx]; 3452 3453 if (*best_item == NULL 3454 || (item->line < (*best_item)->line && item->is_stmt)) 3455 *best_item = item; 3456 3457 break; 3458 } 3459 3460 result.push_back (symtab->linetable ()->item[idx].pc); 3461 start = idx + 1; 3462 } 3463 3464 return result; 3465} 3466 3467 3468/* Set the PC value for a given source file and line number and return true. 3469 Returns false for invalid line number (and sets the PC to 0). 3470 The source file is specified with a struct symtab. */ 3471 3472bool 3473find_line_pc (struct symtab *symtab, int line, CORE_ADDR *pc) 3474{ 3475 struct linetable *l; 3476 int ind; 3477 3478 *pc = 0; 3479 if (symtab == 0) 3480 return false; 3481 3482 symtab = find_line_symtab (symtab, line, &ind, NULL); 3483 if (symtab != NULL) 3484 { 3485 l = symtab->linetable (); 3486 *pc = l->item[ind].pc; 3487 return true; 3488 } 3489 else 3490 return false; 3491} 3492 3493/* Find the range of pc values in a line. 3494 Store the starting pc of the line into *STARTPTR 3495 and the ending pc (start of next line) into *ENDPTR. 3496 Returns true to indicate success. 3497 Returns false if could not find the specified line. */ 3498 3499bool 3500find_line_pc_range (struct symtab_and_line sal, CORE_ADDR *startptr, 3501 CORE_ADDR *endptr) 3502{ 3503 CORE_ADDR startaddr; 3504 struct symtab_and_line found_sal; 3505 3506 startaddr = sal.pc; 3507 if (startaddr == 0 && !find_line_pc (sal.symtab, sal.line, &startaddr)) 3508 return false; 3509 3510 /* This whole function is based on address. For example, if line 10 has 3511 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then 3512 "info line *0x123" should say the line goes from 0x100 to 0x200 3513 and "info line *0x355" should say the line goes from 0x300 to 0x400. 3514 This also insures that we never give a range like "starts at 0x134 3515 and ends at 0x12c". */ 3516 3517 found_sal = find_pc_sect_line (startaddr, sal.section, 0); 3518 if (found_sal.line != sal.line) 3519 { 3520 /* The specified line (sal) has zero bytes. */ 3521 *startptr = found_sal.pc; 3522 *endptr = found_sal.pc; 3523 } 3524 else 3525 { 3526 *startptr = found_sal.pc; 3527 *endptr = found_sal.end; 3528 } 3529 return true; 3530} 3531 3532/* Given a line table and a line number, return the index into the line 3533 table for the pc of the nearest line whose number is >= the specified one. 3534 Return -1 if none is found. The value is >= 0 if it is an index. 3535 START is the index at which to start searching the line table. 3536 3537 Set *EXACT_MATCH nonzero if the value returned is an exact match. */ 3538 3539static int 3540find_line_common (struct linetable *l, int lineno, 3541 int *exact_match, int start) 3542{ 3543 int i; 3544 int len; 3545 3546 /* BEST is the smallest linenumber > LINENO so far seen, 3547 or 0 if none has been seen so far. 3548 BEST_INDEX identifies the item for it. */ 3549 3550 int best_index = -1; 3551 int best = 0; 3552 3553 *exact_match = 0; 3554 3555 if (lineno <= 0) 3556 return -1; 3557 if (l == 0) 3558 return -1; 3559 3560 len = l->nitems; 3561 for (i = start; i < len; i++) 3562 { 3563 struct linetable_entry *item = &(l->item[i]); 3564 3565 /* Ignore non-statements. */ 3566 if (!item->is_stmt) 3567 continue; 3568 3569 if (item->line == lineno) 3570 { 3571 /* Return the first (lowest address) entry which matches. */ 3572 *exact_match = 1; 3573 return i; 3574 } 3575 3576 if (item->line > lineno && (best == 0 || item->line < best)) 3577 { 3578 best = item->line; 3579 best_index = i; 3580 } 3581 } 3582 3583 /* If we got here, we didn't get an exact match. */ 3584 return best_index; 3585} 3586 3587bool 3588find_pc_line_pc_range (CORE_ADDR pc, CORE_ADDR *startptr, CORE_ADDR *endptr) 3589{ 3590 struct symtab_and_line sal; 3591 3592 sal = find_pc_line (pc, 0); 3593 *startptr = sal.pc; 3594 *endptr = sal.end; 3595 return sal.symtab != 0; 3596} 3597 3598/* Helper for find_function_start_sal. Does most of the work, except 3599 setting the sal's symbol. */ 3600 3601static symtab_and_line 3602find_function_start_sal_1 (CORE_ADDR func_addr, obj_section *section, 3603 bool funfirstline) 3604{ 3605 symtab_and_line sal = find_pc_sect_line (func_addr, section, 0); 3606 3607 if (funfirstline && sal.symtab != NULL 3608 && (sal.symtab->compunit ()->locations_valid () 3609 || sal.symtab->language () == language_asm)) 3610 { 3611 struct gdbarch *gdbarch = sal.symtab->compunit ()->objfile ()->arch (); 3612 3613 sal.pc = func_addr; 3614 if (gdbarch_skip_entrypoint_p (gdbarch)) 3615 sal.pc = gdbarch_skip_entrypoint (gdbarch, sal.pc); 3616 return sal; 3617 } 3618 3619 /* We always should have a line for the function start address. 3620 If we don't, something is odd. Create a plain SAL referring 3621 just the PC and hope that skip_prologue_sal (if requested) 3622 can find a line number for after the prologue. */ 3623 if (sal.pc < func_addr) 3624 { 3625 sal = {}; 3626 sal.pspace = current_program_space; 3627 sal.pc = func_addr; 3628 sal.section = section; 3629 } 3630 3631 if (funfirstline) 3632 skip_prologue_sal (&sal); 3633 3634 return sal; 3635} 3636 3637/* See symtab.h. */ 3638 3639symtab_and_line 3640find_function_start_sal (CORE_ADDR func_addr, obj_section *section, 3641 bool funfirstline) 3642{ 3643 symtab_and_line sal 3644 = find_function_start_sal_1 (func_addr, section, funfirstline); 3645 3646 /* find_function_start_sal_1 does a linetable search, so it finds 3647 the symtab and linenumber, but not a symbol. Fill in the 3648 function symbol too. */ 3649 sal.symbol = find_pc_sect_containing_function (sal.pc, sal.section); 3650 3651 return sal; 3652} 3653 3654/* See symtab.h. */ 3655 3656symtab_and_line 3657find_function_start_sal (symbol *sym, bool funfirstline) 3658{ 3659 fixup_symbol_section (sym, NULL); 3660 symtab_and_line sal 3661 = find_function_start_sal_1 (sym->value_block ()->entry_pc (), 3662 sym->obj_section (sym->objfile ()), 3663 funfirstline); 3664 sal.symbol = sym; 3665 return sal; 3666} 3667 3668 3669/* Given a function start address FUNC_ADDR and SYMTAB, find the first 3670 address for that function that has an entry in SYMTAB's line info 3671 table. If such an entry cannot be found, return FUNC_ADDR 3672 unaltered. */ 3673 3674static CORE_ADDR 3675skip_prologue_using_lineinfo (CORE_ADDR func_addr, struct symtab *symtab) 3676{ 3677 CORE_ADDR func_start, func_end; 3678 struct linetable *l; 3679 int i; 3680 3681 /* Give up if this symbol has no lineinfo table. */ 3682 l = symtab->linetable (); 3683 if (l == NULL) 3684 return func_addr; 3685 3686 /* Get the range for the function's PC values, or give up if we 3687 cannot, for some reason. */ 3688 if (!find_pc_partial_function (func_addr, NULL, &func_start, &func_end)) 3689 return func_addr; 3690 3691 /* Linetable entries are ordered by PC values, see the commentary in 3692 symtab.h where `struct linetable' is defined. Thus, the first 3693 entry whose PC is in the range [FUNC_START..FUNC_END[ is the 3694 address we are looking for. */ 3695 for (i = 0; i < l->nitems; i++) 3696 { 3697 struct linetable_entry *item = &(l->item[i]); 3698 3699 /* Don't use line numbers of zero, they mark special entries in 3700 the table. See the commentary on symtab.h before the 3701 definition of struct linetable. */ 3702 if (item->line > 0 && func_start <= item->pc && item->pc < func_end) 3703 return item->pc; 3704 } 3705 3706 return func_addr; 3707} 3708 3709/* Try to locate the address where a breakpoint should be placed past the 3710 prologue of function starting at FUNC_ADDR using the line table. 3711 3712 Return the address associated with the first entry in the line-table for 3713 the function starting at FUNC_ADDR which has prologue_end set to true if 3714 such entry exist, otherwise return an empty optional. */ 3715 3716static gdb::optional<CORE_ADDR> 3717skip_prologue_using_linetable (CORE_ADDR func_addr) 3718{ 3719 CORE_ADDR start_pc, end_pc; 3720 3721 if (!find_pc_partial_function (func_addr, nullptr, &start_pc, &end_pc)) 3722 return {}; 3723 3724 const struct symtab_and_line prologue_sal = find_pc_line (start_pc, 0); 3725 if (prologue_sal.symtab != nullptr 3726 && prologue_sal.symtab->language () != language_asm) 3727 { 3728 struct linetable *linetable = prologue_sal.symtab->linetable (); 3729 3730 auto it = std::lower_bound 3731 (linetable->item, linetable->item + linetable->nitems, start_pc, 3732 [] (const linetable_entry <e, CORE_ADDR pc) -> bool 3733 { 3734 return lte.pc < pc; 3735 }); 3736 3737 for (; 3738 it < linetable->item + linetable->nitems && it->pc < end_pc; 3739 it++) 3740 if (it->prologue_end) 3741 return {it->pc}; 3742 } 3743 3744 return {}; 3745} 3746 3747/* Adjust SAL to the first instruction past the function prologue. 3748 If the PC was explicitly specified, the SAL is not changed. 3749 If the line number was explicitly specified then the SAL can still be 3750 updated, unless the language for SAL is assembler, in which case the SAL 3751 will be left unchanged. 3752 If SAL is already past the prologue, then do nothing. */ 3753 3754void 3755skip_prologue_sal (struct symtab_and_line *sal) 3756{ 3757 struct symbol *sym; 3758 struct symtab_and_line start_sal; 3759 CORE_ADDR pc, saved_pc; 3760 struct obj_section *section; 3761 const char *name; 3762 struct objfile *objfile; 3763 struct gdbarch *gdbarch; 3764 const struct block *b, *function_block; 3765 int force_skip, skip; 3766 3767 /* Do not change the SAL if PC was specified explicitly. */ 3768 if (sal->explicit_pc) 3769 return; 3770 3771 /* In assembly code, if the user asks for a specific line then we should 3772 not adjust the SAL. The user already has instruction level 3773 visibility in this case, so selecting a line other than one requested 3774 is likely to be the wrong choice. */ 3775 if (sal->symtab != nullptr 3776 && sal->explicit_line 3777 && sal->symtab->language () == language_asm) 3778 return; 3779 3780 scoped_restore_current_pspace_and_thread restore_pspace_thread; 3781 3782 switch_to_program_space_and_thread (sal->pspace); 3783 3784 sym = find_pc_sect_function (sal->pc, sal->section); 3785 if (sym != NULL) 3786 { 3787 fixup_symbol_section (sym, NULL); 3788 3789 objfile = sym->objfile (); 3790 pc = sym->value_block ()->entry_pc (); 3791 section = sym->obj_section (objfile); 3792 name = sym->linkage_name (); 3793 } 3794 else 3795 { 3796 struct bound_minimal_symbol msymbol 3797 = lookup_minimal_symbol_by_pc_section (sal->pc, sal->section); 3798 3799 if (msymbol.minsym == NULL) 3800 return; 3801 3802 objfile = msymbol.objfile; 3803 pc = msymbol.value_address (); 3804 section = msymbol.minsym->obj_section (objfile); 3805 name = msymbol.minsym->linkage_name (); 3806 } 3807 3808 gdbarch = objfile->arch (); 3809 3810 /* Process the prologue in two passes. In the first pass try to skip the 3811 prologue (SKIP is true) and verify there is a real need for it (indicated 3812 by FORCE_SKIP). If no such reason was found run a second pass where the 3813 prologue is not skipped (SKIP is false). */ 3814 3815 skip = 1; 3816 force_skip = 1; 3817 3818 /* Be conservative - allow direct PC (without skipping prologue) only if we 3819 have proven the CU (Compilation Unit) supports it. sal->SYMTAB does not 3820 have to be set by the caller so we use SYM instead. */ 3821 if (sym != NULL 3822 && sym->symtab ()->compunit ()->locations_valid ()) 3823 force_skip = 0; 3824 3825 saved_pc = pc; 3826 do 3827 { 3828 pc = saved_pc; 3829 3830 /* Check if the compiler explicitly indicated where a breakpoint should 3831 be placed to skip the prologue. */ 3832 if (!ignore_prologue_end_flag && skip) 3833 { 3834 gdb::optional<CORE_ADDR> linetable_pc 3835 = skip_prologue_using_linetable (pc); 3836 if (linetable_pc) 3837 { 3838 pc = *linetable_pc; 3839 start_sal = find_pc_sect_line (pc, section, 0); 3840 force_skip = 1; 3841 continue; 3842 } 3843 } 3844 3845 /* If the function is in an unmapped overlay, use its unmapped LMA address, 3846 so that gdbarch_skip_prologue has something unique to work on. */ 3847 if (section_is_overlay (section) && !section_is_mapped (section)) 3848 pc = overlay_unmapped_address (pc, section); 3849 3850 /* Skip "first line" of function (which is actually its prologue). */ 3851 pc += gdbarch_deprecated_function_start_offset (gdbarch); 3852 if (gdbarch_skip_entrypoint_p (gdbarch)) 3853 pc = gdbarch_skip_entrypoint (gdbarch, pc); 3854 if (skip) 3855 pc = gdbarch_skip_prologue_noexcept (gdbarch, pc); 3856 3857 /* For overlays, map pc back into its mapped VMA range. */ 3858 pc = overlay_mapped_address (pc, section); 3859 3860 /* Calculate line number. */ 3861 start_sal = find_pc_sect_line (pc, section, 0); 3862 3863 /* Check if gdbarch_skip_prologue left us in mid-line, and the next 3864 line is still part of the same function. */ 3865 if (skip && start_sal.pc != pc 3866 && (sym ? (sym->value_block ()->entry_pc () <= start_sal.end 3867 && start_sal.end < sym->value_block()->end ()) 3868 : (lookup_minimal_symbol_by_pc_section (start_sal.end, section).minsym 3869 == lookup_minimal_symbol_by_pc_section (pc, section).minsym))) 3870 { 3871 /* First pc of next line */ 3872 pc = start_sal.end; 3873 /* Recalculate the line number (might not be N+1). */ 3874 start_sal = find_pc_sect_line (pc, section, 0); 3875 } 3876 3877 /* On targets with executable formats that don't have a concept of 3878 constructors (ELF with .init has, PE doesn't), gcc emits a call 3879 to `__main' in `main' between the prologue and before user 3880 code. */ 3881 if (gdbarch_skip_main_prologue_p (gdbarch) 3882 && name && strcmp_iw (name, "main") == 0) 3883 { 3884 pc = gdbarch_skip_main_prologue (gdbarch, pc); 3885 /* Recalculate the line number (might not be N+1). */ 3886 start_sal = find_pc_sect_line (pc, section, 0); 3887 force_skip = 1; 3888 } 3889 } 3890 while (!force_skip && skip--); 3891 3892 /* If we still don't have a valid source line, try to find the first 3893 PC in the lineinfo table that belongs to the same function. This 3894 happens with COFF debug info, which does not seem to have an 3895 entry in lineinfo table for the code after the prologue which has 3896 no direct relation to source. For example, this was found to be 3897 the case with the DJGPP target using "gcc -gcoff" when the 3898 compiler inserted code after the prologue to make sure the stack 3899 is aligned. */ 3900 if (!force_skip && sym && start_sal.symtab == NULL) 3901 { 3902 pc = skip_prologue_using_lineinfo (pc, sym->symtab ()); 3903 /* Recalculate the line number. */ 3904 start_sal = find_pc_sect_line (pc, section, 0); 3905 } 3906 3907 /* If we're already past the prologue, leave SAL unchanged. Otherwise 3908 forward SAL to the end of the prologue. */ 3909 if (sal->pc >= pc) 3910 return; 3911 3912 sal->pc = pc; 3913 sal->section = section; 3914 sal->symtab = start_sal.symtab; 3915 sal->line = start_sal.line; 3916 sal->end = start_sal.end; 3917 3918 /* Check if we are now inside an inlined function. If we can, 3919 use the call site of the function instead. */ 3920 b = block_for_pc_sect (sal->pc, sal->section); 3921 function_block = NULL; 3922 while (b != NULL) 3923 { 3924 if (b->function () != NULL && block_inlined_p (b)) 3925 function_block = b; 3926 else if (b->function () != NULL) 3927 break; 3928 b = b->superblock (); 3929 } 3930 if (function_block != NULL 3931 && function_block->function ()->line () != 0) 3932 { 3933 sal->line = function_block->function ()->line (); 3934 sal->symtab = function_block->function ()->symtab (); 3935 } 3936} 3937 3938/* Given PC at the function's start address, attempt to find the 3939 prologue end using SAL information. Return zero if the skip fails. 3940 3941 A non-optimized prologue traditionally has one SAL for the function 3942 and a second for the function body. A single line function has 3943 them both pointing at the same line. 3944 3945 An optimized prologue is similar but the prologue may contain 3946 instructions (SALs) from the instruction body. Need to skip those 3947 while not getting into the function body. 3948 3949 The functions end point and an increasing SAL line are used as 3950 indicators of the prologue's endpoint. 3951 3952 This code is based on the function refine_prologue_limit 3953 (found in ia64). */ 3954 3955CORE_ADDR 3956skip_prologue_using_sal (struct gdbarch *gdbarch, CORE_ADDR func_addr) 3957{ 3958 struct symtab_and_line prologue_sal; 3959 CORE_ADDR start_pc; 3960 CORE_ADDR end_pc; 3961 const struct block *bl; 3962 3963 /* Get an initial range for the function. */ 3964 find_pc_partial_function (func_addr, NULL, &start_pc, &end_pc); 3965 start_pc += gdbarch_deprecated_function_start_offset (gdbarch); 3966 3967 prologue_sal = find_pc_line (start_pc, 0); 3968 if (prologue_sal.line != 0) 3969 { 3970 /* For languages other than assembly, treat two consecutive line 3971 entries at the same address as a zero-instruction prologue. 3972 The GNU assembler emits separate line notes for each instruction 3973 in a multi-instruction macro, but compilers generally will not 3974 do this. */ 3975 if (prologue_sal.symtab->language () != language_asm) 3976 { 3977 struct linetable *linetable = prologue_sal.symtab->linetable (); 3978 int idx = 0; 3979 3980 /* Skip any earlier lines, and any end-of-sequence marker 3981 from a previous function. */ 3982 while (linetable->item[idx].pc != prologue_sal.pc 3983 || linetable->item[idx].line == 0) 3984 idx++; 3985 3986 if (idx+1 < linetable->nitems 3987 && linetable->item[idx+1].line != 0 3988 && linetable->item[idx+1].pc == start_pc) 3989 return start_pc; 3990 } 3991 3992 /* If there is only one sal that covers the entire function, 3993 then it is probably a single line function, like 3994 "foo(){}". */ 3995 if (prologue_sal.end >= end_pc) 3996 return 0; 3997 3998 while (prologue_sal.end < end_pc) 3999 { 4000 struct symtab_and_line sal; 4001 4002 sal = find_pc_line (prologue_sal.end, 0); 4003 if (sal.line == 0) 4004 break; 4005 /* Assume that a consecutive SAL for the same (or larger) 4006 line mark the prologue -> body transition. */ 4007 if (sal.line >= prologue_sal.line) 4008 break; 4009 /* Likewise if we are in a different symtab altogether 4010 (e.g. within a file included via #include).�� */ 4011 if (sal.symtab != prologue_sal.symtab) 4012 break; 4013 4014 /* The line number is smaller. Check that it's from the 4015 same function, not something inlined. If it's inlined, 4016 then there is no point comparing the line numbers. */ 4017 bl = block_for_pc (prologue_sal.end); 4018 while (bl) 4019 { 4020 if (block_inlined_p (bl)) 4021 break; 4022 if (bl->function ()) 4023 { 4024 bl = NULL; 4025 break; 4026 } 4027 bl = bl->superblock (); 4028 } 4029 if (bl != NULL) 4030 break; 4031 4032 /* The case in which compiler's optimizer/scheduler has 4033 moved instructions into the prologue. We look ahead in 4034 the function looking for address ranges whose 4035 corresponding line number is less the first one that we 4036 found for the function. This is more conservative then 4037 refine_prologue_limit which scans a large number of SALs 4038 looking for any in the prologue. */ 4039 prologue_sal = sal; 4040 } 4041 } 4042 4043 if (prologue_sal.end < end_pc) 4044 /* Return the end of this line, or zero if we could not find a 4045 line. */ 4046 return prologue_sal.end; 4047 else 4048 /* Don't return END_PC, which is past the end of the function. */ 4049 return prologue_sal.pc; 4050} 4051 4052/* See symtab.h. */ 4053 4054symbol * 4055find_function_alias_target (bound_minimal_symbol msymbol) 4056{ 4057 CORE_ADDR func_addr; 4058 if (!msymbol_is_function (msymbol.objfile, msymbol.minsym, &func_addr)) 4059 return NULL; 4060 4061 symbol *sym = find_pc_function (func_addr); 4062 if (sym != NULL 4063 && sym->aclass () == LOC_BLOCK 4064 && sym->value_block ()->entry_pc () == func_addr) 4065 return sym; 4066 4067 return NULL; 4068} 4069 4070 4071/* If P is of the form "operator[ \t]+..." where `...' is 4072 some legitimate operator text, return a pointer to the 4073 beginning of the substring of the operator text. 4074 Otherwise, return "". */ 4075 4076static const char * 4077operator_chars (const char *p, const char **end) 4078{ 4079 *end = ""; 4080 if (!startswith (p, CP_OPERATOR_STR)) 4081 return *end; 4082 p += CP_OPERATOR_LEN; 4083 4084 /* Don't get faked out by `operator' being part of a longer 4085 identifier. */ 4086 if (isalpha (*p) || *p == '_' || *p == '$' || *p == '\0') 4087 return *end; 4088 4089 /* Allow some whitespace between `operator' and the operator symbol. */ 4090 while (*p == ' ' || *p == '\t') 4091 p++; 4092 4093 /* Recognize 'operator TYPENAME'. */ 4094 4095 if (isalpha (*p) || *p == '_' || *p == '$') 4096 { 4097 const char *q = p + 1; 4098 4099 while (isalnum (*q) || *q == '_' || *q == '$') 4100 q++; 4101 *end = q; 4102 return p; 4103 } 4104 4105 while (*p) 4106 switch (*p) 4107 { 4108 case '\\': /* regexp quoting */ 4109 if (p[1] == '*') 4110 { 4111 if (p[2] == '=') /* 'operator\*=' */ 4112 *end = p + 3; 4113 else /* 'operator\*' */ 4114 *end = p + 2; 4115 return p; 4116 } 4117 else if (p[1] == '[') 4118 { 4119 if (p[2] == ']') 4120 error (_("mismatched quoting on brackets, " 4121 "try 'operator\\[\\]'")); 4122 else if (p[2] == '\\' && p[3] == ']') 4123 { 4124 *end = p + 4; /* 'operator\[\]' */ 4125 return p; 4126 } 4127 else 4128 error (_("nothing is allowed between '[' and ']'")); 4129 } 4130 else 4131 { 4132 /* Gratuitous quote: skip it and move on. */ 4133 p++; 4134 continue; 4135 } 4136 break; 4137 case '!': 4138 case '=': 4139 case '*': 4140 case '/': 4141 case '%': 4142 case '^': 4143 if (p[1] == '=') 4144 *end = p + 2; 4145 else 4146 *end = p + 1; 4147 return p; 4148 case '<': 4149 case '>': 4150 case '+': 4151 case '-': 4152 case '&': 4153 case '|': 4154 if (p[0] == '-' && p[1] == '>') 4155 { 4156 /* Struct pointer member operator 'operator->'. */ 4157 if (p[2] == '*') 4158 { 4159 *end = p + 3; /* 'operator->*' */ 4160 return p; 4161 } 4162 else if (p[2] == '\\') 4163 { 4164 *end = p + 4; /* Hopefully 'operator->\*' */ 4165 return p; 4166 } 4167 else 4168 { 4169 *end = p + 2; /* 'operator->' */ 4170 return p; 4171 } 4172 } 4173 if (p[1] == '=' || p[1] == p[0]) 4174 *end = p + 2; 4175 else 4176 *end = p + 1; 4177 return p; 4178 case '~': 4179 case ',': 4180 *end = p + 1; 4181 return p; 4182 case '(': 4183 if (p[1] != ')') 4184 error (_("`operator ()' must be specified " 4185 "without whitespace in `()'")); 4186 *end = p + 2; 4187 return p; 4188 case '?': 4189 if (p[1] != ':') 4190 error (_("`operator ?:' must be specified " 4191 "without whitespace in `?:'")); 4192 *end = p + 2; 4193 return p; 4194 case '[': 4195 if (p[1] != ']') 4196 error (_("`operator []' must be specified " 4197 "without whitespace in `[]'")); 4198 *end = p + 2; 4199 return p; 4200 default: 4201 error (_("`operator %s' not supported"), p); 4202 break; 4203 } 4204 4205 *end = ""; 4206 return *end; 4207} 4208 4209 4210/* See class declaration. */ 4211 4212info_sources_filter::info_sources_filter (match_on match_type, 4213 const char *regexp) 4214 : m_match_type (match_type), 4215 m_regexp (regexp) 4216{ 4217 /* Setup the compiled regular expression M_C_REGEXP based on M_REGEXP. */ 4218 if (m_regexp != nullptr && *m_regexp != '\0') 4219 { 4220 gdb_assert (m_regexp != nullptr); 4221 4222 int cflags = REG_NOSUB; 4223#ifdef HAVE_CASE_INSENSITIVE_FILE_SYSTEM 4224 cflags |= REG_ICASE; 4225#endif 4226 m_c_regexp.emplace (m_regexp, cflags, _("Invalid regexp")); 4227 } 4228} 4229 4230/* See class declaration. */ 4231 4232bool 4233info_sources_filter::matches (const char *fullname) const 4234{ 4235 /* Does it match regexp? */ 4236 if (m_c_regexp.has_value ()) 4237 { 4238 const char *to_match; 4239 std::string dirname; 4240 4241 switch (m_match_type) 4242 { 4243 case match_on::DIRNAME: 4244 dirname = ldirname (fullname); 4245 to_match = dirname.c_str (); 4246 break; 4247 case match_on::BASENAME: 4248 to_match = lbasename (fullname); 4249 break; 4250 case match_on::FULLNAME: 4251 to_match = fullname; 4252 break; 4253 default: 4254 gdb_assert_not_reached ("bad m_match_type"); 4255 } 4256 4257 if (m_c_regexp->exec (to_match, 0, NULL, 0) != 0) 4258 return false; 4259 } 4260 4261 return true; 4262} 4263 4264/* Data structure to maintain the state used for printing the results of 4265 the 'info sources' command. */ 4266 4267struct output_source_filename_data 4268{ 4269 /* Create an object for displaying the results of the 'info sources' 4270 command to UIOUT. FILTER must remain valid and unchanged for the 4271 lifetime of this object as this object retains a reference to FILTER. */ 4272 output_source_filename_data (struct ui_out *uiout, 4273 const info_sources_filter &filter) 4274 : m_filter (filter), 4275 m_uiout (uiout) 4276 { /* Nothing. */ } 4277 4278 DISABLE_COPY_AND_ASSIGN (output_source_filename_data); 4279 4280 /* Reset enough state of this object so we can match against a new set of 4281 files. The existing regular expression is retained though. */ 4282 void reset_output () 4283 { 4284 m_first = true; 4285 m_filename_seen_cache.clear (); 4286 } 4287 4288 /* Worker for sources_info, outputs the file name formatted for either 4289 cli or mi (based on the current_uiout). In cli mode displays 4290 FULLNAME with a comma separating this name from any previously 4291 printed name (line breaks are added at the comma). In MI mode 4292 outputs a tuple containing DISP_NAME (the files display name), 4293 FULLNAME, and EXPANDED_P (true when this file is from a fully 4294 expanded symtab, otherwise false). */ 4295 void output (const char *disp_name, const char *fullname, bool expanded_p); 4296 4297 /* An overload suitable for use as a callback to 4298 quick_symbol_functions::map_symbol_filenames. */ 4299 void operator() (const char *filename, const char *fullname) 4300 { 4301 /* The false here indicates that this file is from an unexpanded 4302 symtab. */ 4303 output (filename, fullname, false); 4304 } 4305 4306 /* Return true if at least one filename has been printed (after a call to 4307 output) since either this object was created, or the last call to 4308 reset_output. */ 4309 bool printed_filename_p () const 4310 { 4311 return !m_first; 4312 } 4313 4314private: 4315 4316 /* Flag of whether we're printing the first one. */ 4317 bool m_first = true; 4318 4319 /* Cache of what we've seen so far. */ 4320 filename_seen_cache m_filename_seen_cache; 4321 4322 /* How source filename should be filtered. */ 4323 const info_sources_filter &m_filter; 4324 4325 /* The object to which output is sent. */ 4326 struct ui_out *m_uiout; 4327}; 4328 4329/* See comment in class declaration above. */ 4330 4331void 4332output_source_filename_data::output (const char *disp_name, 4333 const char *fullname, 4334 bool expanded_p) 4335{ 4336 /* Since a single source file can result in several partial symbol 4337 tables, we need to avoid printing it more than once. Note: if 4338 some of the psymtabs are read in and some are not, it gets 4339 printed both under "Source files for which symbols have been 4340 read" and "Source files for which symbols will be read in on 4341 demand". I consider this a reasonable way to deal with the 4342 situation. I'm not sure whether this can also happen for 4343 symtabs; it doesn't hurt to check. */ 4344 4345 /* Was NAME already seen? If so, then don't print it again. */ 4346 if (m_filename_seen_cache.seen (fullname)) 4347 return; 4348 4349 /* If the filter rejects this file then don't print it. */ 4350 if (!m_filter.matches (fullname)) 4351 return; 4352 4353 ui_out_emit_tuple ui_emitter (m_uiout, nullptr); 4354 4355 /* Print it and reset *FIRST. */ 4356 if (!m_first) 4357 m_uiout->text (", "); 4358 m_first = false; 4359 4360 m_uiout->wrap_hint (0); 4361 if (m_uiout->is_mi_like_p ()) 4362 { 4363 m_uiout->field_string ("file", disp_name, file_name_style.style ()); 4364 if (fullname != nullptr) 4365 m_uiout->field_string ("fullname", fullname, 4366 file_name_style.style ()); 4367 m_uiout->field_string ("debug-fully-read", 4368 (expanded_p ? "true" : "false")); 4369 } 4370 else 4371 { 4372 if (fullname == nullptr) 4373 fullname = disp_name; 4374 m_uiout->field_string ("fullname", fullname, 4375 file_name_style.style ()); 4376 } 4377} 4378 4379/* For the 'info sources' command, what part of the file names should we be 4380 matching the user supplied regular expression against? */ 4381 4382struct filename_partial_match_opts 4383{ 4384 /* Only match the directory name part. */ 4385 bool dirname = false; 4386 4387 /* Only match the basename part. */ 4388 bool basename = false; 4389}; 4390 4391using isrc_flag_option_def 4392 = gdb::option::flag_option_def<filename_partial_match_opts>; 4393 4394static const gdb::option::option_def info_sources_option_defs[] = { 4395 4396 isrc_flag_option_def { 4397 "dirname", 4398 [] (filename_partial_match_opts *opts) { return &opts->dirname; }, 4399 N_("Show only the files having a dirname matching REGEXP."), 4400 }, 4401 4402 isrc_flag_option_def { 4403 "basename", 4404 [] (filename_partial_match_opts *opts) { return &opts->basename; }, 4405 N_("Show only the files having a basename matching REGEXP."), 4406 }, 4407 4408}; 4409 4410/* Create an option_def_group for the "info sources" options, with 4411 ISRC_OPTS as context. */ 4412 4413static inline gdb::option::option_def_group 4414make_info_sources_options_def_group (filename_partial_match_opts *isrc_opts) 4415{ 4416 return {{info_sources_option_defs}, isrc_opts}; 4417} 4418 4419/* Completer for "info sources". */ 4420 4421static void 4422info_sources_command_completer (cmd_list_element *ignore, 4423 completion_tracker &tracker, 4424 const char *text, const char *word) 4425{ 4426 const auto group = make_info_sources_options_def_group (nullptr); 4427 if (gdb::option::complete_options 4428 (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, group)) 4429 return; 4430} 4431 4432/* See symtab.h. */ 4433 4434void 4435info_sources_worker (struct ui_out *uiout, 4436 bool group_by_objfile, 4437 const info_sources_filter &filter) 4438{ 4439 output_source_filename_data data (uiout, filter); 4440 4441 ui_out_emit_list results_emitter (uiout, "files"); 4442 gdb::optional<ui_out_emit_tuple> output_tuple; 4443 gdb::optional<ui_out_emit_list> sources_list; 4444 4445 gdb_assert (group_by_objfile || uiout->is_mi_like_p ()); 4446 4447 for (objfile *objfile : current_program_space->objfiles ()) 4448 { 4449 if (group_by_objfile) 4450 { 4451 output_tuple.emplace (uiout, nullptr); 4452 uiout->field_string ("filename", objfile_name (objfile), 4453 file_name_style.style ()); 4454 uiout->text (":\n"); 4455 bool debug_fully_readin = !objfile->has_unexpanded_symtabs (); 4456 if (uiout->is_mi_like_p ()) 4457 { 4458 const char *debug_info_state; 4459 if (objfile_has_symbols (objfile)) 4460 { 4461 if (debug_fully_readin) 4462 debug_info_state = "fully-read"; 4463 else 4464 debug_info_state = "partially-read"; 4465 } 4466 else 4467 debug_info_state = "none"; 4468 current_uiout->field_string ("debug-info", debug_info_state); 4469 } 4470 else 4471 { 4472 if (!debug_fully_readin) 4473 uiout->text ("(Full debug information has not yet been read " 4474 "for this file.)\n"); 4475 if (!objfile_has_symbols (objfile)) 4476 uiout->text ("(Objfile has no debug information.)\n"); 4477 uiout->text ("\n"); 4478 } 4479 sources_list.emplace (uiout, "sources"); 4480 } 4481 4482 for (compunit_symtab *cu : objfile->compunits ()) 4483 { 4484 for (symtab *s : cu->filetabs ()) 4485 { 4486 const char *file = symtab_to_filename_for_display (s); 4487 const char *fullname = symtab_to_fullname (s); 4488 data.output (file, fullname, true); 4489 } 4490 } 4491 4492 if (group_by_objfile) 4493 { 4494 objfile->map_symbol_filenames (data, true /* need_fullname */); 4495 if (data.printed_filename_p ()) 4496 uiout->text ("\n\n"); 4497 data.reset_output (); 4498 sources_list.reset (); 4499 output_tuple.reset (); 4500 } 4501 } 4502 4503 if (!group_by_objfile) 4504 { 4505 data.reset_output (); 4506 map_symbol_filenames (data, true /*need_fullname*/); 4507 } 4508} 4509 4510/* Implement the 'info sources' command. */ 4511 4512static void 4513info_sources_command (const char *args, int from_tty) 4514{ 4515 if (!have_full_symbols () && !have_partial_symbols ()) 4516 error (_("No symbol table is loaded. Use the \"file\" command.")); 4517 4518 filename_partial_match_opts match_opts; 4519 auto group = make_info_sources_options_def_group (&match_opts); 4520 gdb::option::process_options 4521 (&args, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR, group); 4522 4523 if (match_opts.dirname && match_opts.basename) 4524 error (_("You cannot give both -basename and -dirname to 'info sources'.")); 4525 4526 const char *regex = nullptr; 4527 if (args != NULL && *args != '\000') 4528 regex = args; 4529 4530 if ((match_opts.dirname || match_opts.basename) && regex == nullptr) 4531 error (_("Missing REGEXP for 'info sources'.")); 4532 4533 info_sources_filter::match_on match_type; 4534 if (match_opts.dirname) 4535 match_type = info_sources_filter::match_on::DIRNAME; 4536 else if (match_opts.basename) 4537 match_type = info_sources_filter::match_on::BASENAME; 4538 else 4539 match_type = info_sources_filter::match_on::FULLNAME; 4540 4541 info_sources_filter filter (match_type, regex); 4542 info_sources_worker (current_uiout, true, filter); 4543} 4544 4545/* Compare FILE against all the entries of FILENAMES. If BASENAMES is 4546 true compare only lbasename of FILENAMES. */ 4547 4548static bool 4549file_matches (const char *file, const std::vector<const char *> &filenames, 4550 bool basenames) 4551{ 4552 if (filenames.empty ()) 4553 return true; 4554 4555 for (const char *name : filenames) 4556 { 4557 name = (basenames ? lbasename (name) : name); 4558 if (compare_filenames_for_search (file, name)) 4559 return true; 4560 } 4561 4562 return false; 4563} 4564 4565/* Helper function for std::sort on symbol_search objects. Can only sort 4566 symbols, not minimal symbols. */ 4567 4568int 4569symbol_search::compare_search_syms (const symbol_search &sym_a, 4570 const symbol_search &sym_b) 4571{ 4572 int c; 4573 4574 c = FILENAME_CMP (sym_a.symbol->symtab ()->filename, 4575 sym_b.symbol->symtab ()->filename); 4576 if (c != 0) 4577 return c; 4578 4579 if (sym_a.block != sym_b.block) 4580 return sym_a.block - sym_b.block; 4581 4582 return strcmp (sym_a.symbol->print_name (), sym_b.symbol->print_name ()); 4583} 4584 4585/* Returns true if the type_name of symbol_type of SYM matches TREG. 4586 If SYM has no symbol_type or symbol_name, returns false. */ 4587 4588bool 4589treg_matches_sym_type_name (const compiled_regex &treg, 4590 const struct symbol *sym) 4591{ 4592 struct type *sym_type; 4593 std::string printed_sym_type_name; 4594 4595 symbol_lookup_debug_printf_v ("treg_matches_sym_type_name, sym %s", 4596 sym->natural_name ()); 4597 4598 sym_type = sym->type (); 4599 if (sym_type == NULL) 4600 return false; 4601 4602 { 4603 scoped_switch_to_sym_language_if_auto l (sym); 4604 4605 printed_sym_type_name = type_to_string (sym_type); 4606 } 4607 4608 symbol_lookup_debug_printf_v ("sym_type_name %s", 4609 printed_sym_type_name.c_str ()); 4610 4611 if (printed_sym_type_name.empty ()) 4612 return false; 4613 4614 return treg.exec (printed_sym_type_name.c_str (), 0, NULL, 0) == 0; 4615} 4616 4617/* See symtab.h. */ 4618 4619bool 4620global_symbol_searcher::is_suitable_msymbol 4621 (const enum search_domain kind, const minimal_symbol *msymbol) 4622{ 4623 switch (msymbol->type ()) 4624 { 4625 case mst_data: 4626 case mst_bss: 4627 case mst_file_data: 4628 case mst_file_bss: 4629 return kind == VARIABLES_DOMAIN; 4630 case mst_text: 4631 case mst_file_text: 4632 case mst_solib_trampoline: 4633 case mst_text_gnu_ifunc: 4634 return kind == FUNCTIONS_DOMAIN; 4635 default: 4636 return false; 4637 } 4638} 4639 4640/* See symtab.h. */ 4641 4642bool 4643global_symbol_searcher::expand_symtabs 4644 (objfile *objfile, const gdb::optional<compiled_regex> &preg) const 4645{ 4646 enum search_domain kind = m_kind; 4647 bool found_msymbol = false; 4648 4649 auto do_file_match = [&] (const char *filename, bool basenames) 4650 { 4651 return file_matches (filename, filenames, basenames); 4652 }; 4653 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher = nullptr; 4654 if (!filenames.empty ()) 4655 file_matcher = do_file_match; 4656 4657 objfile->expand_symtabs_matching 4658 (file_matcher, 4659 &lookup_name_info::match_any (), 4660 [&] (const char *symname) 4661 { 4662 return (!preg.has_value () 4663 || preg->exec (symname, 0, NULL, 0) == 0); 4664 }, 4665 NULL, 4666 SEARCH_GLOBAL_BLOCK | SEARCH_STATIC_BLOCK, 4667 UNDEF_DOMAIN, 4668 kind); 4669 4670 /* Here, we search through the minimal symbol tables for functions and 4671 variables that match, and force their symbols to be read. This is in 4672 particular necessary for demangled variable names, which are no longer 4673 put into the partial symbol tables. The symbol will then be found 4674 during the scan of symtabs later. 4675 4676 For functions, find_pc_symtab should succeed if we have debug info for 4677 the function, for variables we have to call 4678 lookup_symbol_in_objfile_from_linkage_name to determine if the 4679 variable has debug info. If the lookup fails, set found_msymbol so 4680 that we will rescan to print any matching symbols without debug info. 4681 We only search the objfile the msymbol came from, we no longer search 4682 all objfiles. In large programs (1000s of shared libs) searching all 4683 objfiles is not worth the pain. */ 4684 if (filenames.empty () 4685 && (kind == VARIABLES_DOMAIN || kind == FUNCTIONS_DOMAIN)) 4686 { 4687 for (minimal_symbol *msymbol : objfile->msymbols ()) 4688 { 4689 QUIT; 4690 4691 if (msymbol->created_by_gdb) 4692 continue; 4693 4694 if (is_suitable_msymbol (kind, msymbol)) 4695 { 4696 if (!preg.has_value () 4697 || preg->exec (msymbol->natural_name (), 0, 4698 NULL, 0) == 0) 4699 { 4700 /* An important side-effect of these lookup functions is 4701 to expand the symbol table if msymbol is found, later 4702 in the process we will add matching symbols or 4703 msymbols to the results list, and that requires that 4704 the symbols tables are expanded. */ 4705 if (kind == FUNCTIONS_DOMAIN 4706 ? (find_pc_compunit_symtab 4707 (msymbol->value_address (objfile)) == NULL) 4708 : (lookup_symbol_in_objfile_from_linkage_name 4709 (objfile, msymbol->linkage_name (), 4710 VAR_DOMAIN) 4711 .symbol == NULL)) 4712 found_msymbol = true; 4713 } 4714 } 4715 } 4716 } 4717 4718 return found_msymbol; 4719} 4720 4721/* See symtab.h. */ 4722 4723bool 4724global_symbol_searcher::add_matching_symbols 4725 (objfile *objfile, 4726 const gdb::optional<compiled_regex> &preg, 4727 const gdb::optional<compiled_regex> &treg, 4728 std::set<symbol_search> *result_set) const 4729{ 4730 enum search_domain kind = m_kind; 4731 4732 /* Add matching symbols (if not already present). */ 4733 for (compunit_symtab *cust : objfile->compunits ()) 4734 { 4735 const struct blockvector *bv = cust->blockvector (); 4736 4737 for (block_enum block : { GLOBAL_BLOCK, STATIC_BLOCK }) 4738 { 4739 struct block_iterator iter; 4740 struct symbol *sym; 4741 const struct block *b = bv->block (block); 4742 4743 ALL_BLOCK_SYMBOLS (b, iter, sym) 4744 { 4745 struct symtab *real_symtab = sym->symtab (); 4746 4747 QUIT; 4748 4749 /* Check first sole REAL_SYMTAB->FILENAME. It does 4750 not need to be a substring of symtab_to_fullname as 4751 it may contain "./" etc. */ 4752 if ((file_matches (real_symtab->filename, filenames, false) 4753 || ((basenames_may_differ 4754 || file_matches (lbasename (real_symtab->filename), 4755 filenames, true)) 4756 && file_matches (symtab_to_fullname (real_symtab), 4757 filenames, false))) 4758 && ((!preg.has_value () 4759 || preg->exec (sym->natural_name (), 0, 4760 NULL, 0) == 0) 4761 && ((kind == VARIABLES_DOMAIN 4762 && sym->aclass () != LOC_TYPEDEF 4763 && sym->aclass () != LOC_UNRESOLVED 4764 && sym->aclass () != LOC_BLOCK 4765 /* LOC_CONST can be used for more than 4766 just enums, e.g., c++ static const 4767 members. We only want to skip enums 4768 here. */ 4769 && !(sym->aclass () == LOC_CONST 4770 && (sym->type ()->code () 4771 == TYPE_CODE_ENUM)) 4772 && (!treg.has_value () 4773 || treg_matches_sym_type_name (*treg, sym))) 4774 || (kind == FUNCTIONS_DOMAIN 4775 && sym->aclass () == LOC_BLOCK 4776 && (!treg.has_value () 4777 || treg_matches_sym_type_name (*treg, 4778 sym))) 4779 || (kind == TYPES_DOMAIN 4780 && sym->aclass () == LOC_TYPEDEF 4781 && sym->domain () != MODULE_DOMAIN) 4782 || (kind == MODULES_DOMAIN 4783 && sym->domain () == MODULE_DOMAIN 4784 && sym->line () != 0)))) 4785 { 4786 if (result_set->size () < m_max_search_results) 4787 { 4788 /* Match, insert if not already in the results. */ 4789 symbol_search ss (block, sym); 4790 if (result_set->find (ss) == result_set->end ()) 4791 result_set->insert (ss); 4792 } 4793 else 4794 return false; 4795 } 4796 } 4797 } 4798 } 4799 4800 return true; 4801} 4802 4803/* See symtab.h. */ 4804 4805bool 4806global_symbol_searcher::add_matching_msymbols 4807 (objfile *objfile, const gdb::optional<compiled_regex> &preg, 4808 std::vector<symbol_search> *results) const 4809{ 4810 enum search_domain kind = m_kind; 4811 4812 for (minimal_symbol *msymbol : objfile->msymbols ()) 4813 { 4814 QUIT; 4815 4816 if (msymbol->created_by_gdb) 4817 continue; 4818 4819 if (is_suitable_msymbol (kind, msymbol)) 4820 { 4821 if (!preg.has_value () 4822 || preg->exec (msymbol->natural_name (), 0, 4823 NULL, 0) == 0) 4824 { 4825 /* For functions we can do a quick check of whether the 4826 symbol might be found via find_pc_symtab. */ 4827 if (kind != FUNCTIONS_DOMAIN 4828 || (find_pc_compunit_symtab 4829 (msymbol->value_address (objfile)) == NULL)) 4830 { 4831 if (lookup_symbol_in_objfile_from_linkage_name 4832 (objfile, msymbol->linkage_name (), 4833 VAR_DOMAIN).symbol == NULL) 4834 { 4835 /* Matching msymbol, add it to the results list. */ 4836 if (results->size () < m_max_search_results) 4837 results->emplace_back (GLOBAL_BLOCK, msymbol, objfile); 4838 else 4839 return false; 4840 } 4841 } 4842 } 4843 } 4844 } 4845 4846 return true; 4847} 4848 4849/* See symtab.h. */ 4850 4851std::vector<symbol_search> 4852global_symbol_searcher::search () const 4853{ 4854 gdb::optional<compiled_regex> preg; 4855 gdb::optional<compiled_regex> treg; 4856 4857 gdb_assert (m_kind != ALL_DOMAIN); 4858 4859 if (m_symbol_name_regexp != NULL) 4860 { 4861 const char *symbol_name_regexp = m_symbol_name_regexp; 4862 std::string symbol_name_regexp_holder; 4863 4864 /* Make sure spacing is right for C++ operators. 4865 This is just a courtesy to make the matching less sensitive 4866 to how many spaces the user leaves between 'operator' 4867 and <TYPENAME> or <OPERATOR>. */ 4868 const char *opend; 4869 const char *opname = operator_chars (symbol_name_regexp, &opend); 4870 4871 if (*opname) 4872 { 4873 int fix = -1; /* -1 means ok; otherwise number of 4874 spaces needed. */ 4875 4876 if (isalpha (*opname) || *opname == '_' || *opname == '$') 4877 { 4878 /* There should 1 space between 'operator' and 'TYPENAME'. */ 4879 if (opname[-1] != ' ' || opname[-2] == ' ') 4880 fix = 1; 4881 } 4882 else 4883 { 4884 /* There should 0 spaces between 'operator' and 'OPERATOR'. */ 4885 if (opname[-1] == ' ') 4886 fix = 0; 4887 } 4888 /* If wrong number of spaces, fix it. */ 4889 if (fix >= 0) 4890 { 4891 symbol_name_regexp_holder 4892 = string_printf ("operator%.*s%s", fix, " ", opname); 4893 symbol_name_regexp = symbol_name_regexp_holder.c_str (); 4894 } 4895 } 4896 4897 int cflags = REG_NOSUB | (case_sensitivity == case_sensitive_off 4898 ? REG_ICASE : 0); 4899 preg.emplace (symbol_name_regexp, cflags, 4900 _("Invalid regexp")); 4901 } 4902 4903 if (m_symbol_type_regexp != NULL) 4904 { 4905 int cflags = REG_NOSUB | (case_sensitivity == case_sensitive_off 4906 ? REG_ICASE : 0); 4907 treg.emplace (m_symbol_type_regexp, cflags, 4908 _("Invalid regexp")); 4909 } 4910 4911 bool found_msymbol = false; 4912 std::set<symbol_search> result_set; 4913 for (objfile *objfile : current_program_space->objfiles ()) 4914 { 4915 /* Expand symtabs within objfile that possibly contain matching 4916 symbols. */ 4917 found_msymbol |= expand_symtabs (objfile, preg); 4918 4919 /* Find matching symbols within OBJFILE and add them in to the 4920 RESULT_SET set. Use a set here so that we can easily detect 4921 duplicates as we go, and can therefore track how many unique 4922 matches we have found so far. */ 4923 if (!add_matching_symbols (objfile, preg, treg, &result_set)) 4924 break; 4925 } 4926 4927 /* Convert the result set into a sorted result list, as std::set is 4928 defined to be sorted then no explicit call to std::sort is needed. */ 4929 std::vector<symbol_search> result (result_set.begin (), result_set.end ()); 4930 4931 /* If there are no debug symbols, then add matching minsyms. But if the 4932 user wants to see symbols matching a type regexp, then never give a 4933 minimal symbol, as we assume that a minimal symbol does not have a 4934 type. */ 4935 if ((found_msymbol || (filenames.empty () && m_kind == VARIABLES_DOMAIN)) 4936 && !m_exclude_minsyms 4937 && !treg.has_value ()) 4938 { 4939 gdb_assert (m_kind == VARIABLES_DOMAIN || m_kind == FUNCTIONS_DOMAIN); 4940 for (objfile *objfile : current_program_space->objfiles ()) 4941 if (!add_matching_msymbols (objfile, preg, &result)) 4942 break; 4943 } 4944 4945 return result; 4946} 4947 4948/* See symtab.h. */ 4949 4950std::string 4951symbol_to_info_string (struct symbol *sym, int block, 4952 enum search_domain kind) 4953{ 4954 std::string str; 4955 4956 gdb_assert (block == GLOBAL_BLOCK || block == STATIC_BLOCK); 4957 4958 if (kind != TYPES_DOMAIN && block == STATIC_BLOCK) 4959 str += "static "; 4960 4961 /* Typedef that is not a C++ class. */ 4962 if (kind == TYPES_DOMAIN 4963 && sym->domain () != STRUCT_DOMAIN) 4964 { 4965 string_file tmp_stream; 4966 4967 /* FIXME: For C (and C++) we end up with a difference in output here 4968 between how a typedef is printed, and non-typedefs are printed. 4969 The TYPEDEF_PRINT code places a ";" at the end in an attempt to 4970 appear C-like, while TYPE_PRINT doesn't. 4971 4972 For the struct printing case below, things are worse, we force 4973 printing of the ";" in this function, which is going to be wrong 4974 for languages that don't require a ";" between statements. */ 4975 if (sym->type ()->code () == TYPE_CODE_TYPEDEF) 4976 typedef_print (sym->type (), sym, &tmp_stream); 4977 else 4978 type_print (sym->type (), "", &tmp_stream, -1); 4979 str += tmp_stream.string (); 4980 } 4981 /* variable, func, or typedef-that-is-c++-class. */ 4982 else if (kind < TYPES_DOMAIN 4983 || (kind == TYPES_DOMAIN 4984 && sym->domain () == STRUCT_DOMAIN)) 4985 { 4986 string_file tmp_stream; 4987 4988 type_print (sym->type (), 4989 (sym->aclass () == LOC_TYPEDEF 4990 ? "" : sym->print_name ()), 4991 &tmp_stream, 0); 4992 4993 str += tmp_stream.string (); 4994 str += ";"; 4995 } 4996 /* Printing of modules is currently done here, maybe at some future 4997 point we might want a language specific method to print the module 4998 symbol so that we can customise the output more. */ 4999 else if (kind == MODULES_DOMAIN) 5000 str += sym->print_name (); 5001 5002 return str; 5003} 5004 5005/* Helper function for symbol info commands, for example 'info functions', 5006 'info variables', etc. KIND is the kind of symbol we searched for, and 5007 BLOCK is the type of block the symbols was found in, either GLOBAL_BLOCK 5008 or STATIC_BLOCK. SYM is the symbol we found. If LAST is not NULL, 5009 print file and line number information for the symbol as well. Skip 5010 printing the filename if it matches LAST. */ 5011 5012static void 5013print_symbol_info (enum search_domain kind, 5014 struct symbol *sym, 5015 int block, const char *last) 5016{ 5017 scoped_switch_to_sym_language_if_auto l (sym); 5018 struct symtab *s = sym->symtab (); 5019 5020 if (last != NULL) 5021 { 5022 const char *s_filename = symtab_to_filename_for_display (s); 5023 5024 if (filename_cmp (last, s_filename) != 0) 5025 { 5026 gdb_printf (_("\nFile %ps:\n"), 5027 styled_string (file_name_style.style (), 5028 s_filename)); 5029 } 5030 5031 if (sym->line () != 0) 5032 gdb_printf ("%d:\t", sym->line ()); 5033 else 5034 gdb_puts ("\t"); 5035 } 5036 5037 std::string str = symbol_to_info_string (sym, block, kind); 5038 gdb_printf ("%s\n", str.c_str ()); 5039} 5040 5041/* This help function for symtab_symbol_info() prints information 5042 for non-debugging symbols to gdb_stdout. */ 5043 5044static void 5045print_msymbol_info (struct bound_minimal_symbol msymbol) 5046{ 5047 struct gdbarch *gdbarch = msymbol.objfile->arch (); 5048 char *tmp; 5049 5050 if (gdbarch_addr_bit (gdbarch) <= 32) 5051 tmp = hex_string_custom (msymbol.value_address () 5052 & (CORE_ADDR) 0xffffffff, 5053 8); 5054 else 5055 tmp = hex_string_custom (msymbol.value_address (), 5056 16); 5057 5058 ui_file_style sym_style = (msymbol.minsym->text_p () 5059 ? function_name_style.style () 5060 : ui_file_style ()); 5061 5062 gdb_printf (_("%ps %ps\n"), 5063 styled_string (address_style.style (), tmp), 5064 styled_string (sym_style, msymbol.minsym->print_name ())); 5065} 5066 5067/* This is the guts of the commands "info functions", "info types", and 5068 "info variables". It calls search_symbols to find all matches and then 5069 print_[m]symbol_info to print out some useful information about the 5070 matches. */ 5071 5072static void 5073symtab_symbol_info (bool quiet, bool exclude_minsyms, 5074 const char *regexp, enum search_domain kind, 5075 const char *t_regexp, int from_tty) 5076{ 5077 static const char * const classnames[] = 5078 {"variable", "function", "type", "module"}; 5079 const char *last_filename = ""; 5080 int first = 1; 5081 5082 gdb_assert (kind != ALL_DOMAIN); 5083 5084 if (regexp != nullptr && *regexp == '\0') 5085 regexp = nullptr; 5086 5087 global_symbol_searcher spec (kind, regexp); 5088 spec.set_symbol_type_regexp (t_regexp); 5089 spec.set_exclude_minsyms (exclude_minsyms); 5090 std::vector<symbol_search> symbols = spec.search (); 5091 5092 if (!quiet) 5093 { 5094 if (regexp != NULL) 5095 { 5096 if (t_regexp != NULL) 5097 gdb_printf 5098 (_("All %ss matching regular expression \"%s\"" 5099 " with type matching regular expression \"%s\":\n"), 5100 classnames[kind], regexp, t_regexp); 5101 else 5102 gdb_printf (_("All %ss matching regular expression \"%s\":\n"), 5103 classnames[kind], regexp); 5104 } 5105 else 5106 { 5107 if (t_regexp != NULL) 5108 gdb_printf 5109 (_("All defined %ss" 5110 " with type matching regular expression \"%s\" :\n"), 5111 classnames[kind], t_regexp); 5112 else 5113 gdb_printf (_("All defined %ss:\n"), classnames[kind]); 5114 } 5115 } 5116 5117 for (const symbol_search &p : symbols) 5118 { 5119 QUIT; 5120 5121 if (p.msymbol.minsym != NULL) 5122 { 5123 if (first) 5124 { 5125 if (!quiet) 5126 gdb_printf (_("\nNon-debugging symbols:\n")); 5127 first = 0; 5128 } 5129 print_msymbol_info (p.msymbol); 5130 } 5131 else 5132 { 5133 print_symbol_info (kind, 5134 p.symbol, 5135 p.block, 5136 last_filename); 5137 last_filename 5138 = symtab_to_filename_for_display (p.symbol->symtab ()); 5139 } 5140 } 5141} 5142 5143/* Structure to hold the values of the options used by the 'info variables' 5144 and 'info functions' commands. These correspond to the -q, -t, and -n 5145 options. */ 5146 5147struct info_vars_funcs_options 5148{ 5149 bool quiet = false; 5150 bool exclude_minsyms = false; 5151 std::string type_regexp; 5152}; 5153 5154/* The options used by the 'info variables' and 'info functions' 5155 commands. */ 5156 5157static const gdb::option::option_def info_vars_funcs_options_defs[] = { 5158 gdb::option::boolean_option_def<info_vars_funcs_options> { 5159 "q", 5160 [] (info_vars_funcs_options *opt) { return &opt->quiet; }, 5161 nullptr, /* show_cmd_cb */ 5162 nullptr /* set_doc */ 5163 }, 5164 5165 gdb::option::boolean_option_def<info_vars_funcs_options> { 5166 "n", 5167 [] (info_vars_funcs_options *opt) { return &opt->exclude_minsyms; }, 5168 nullptr, /* show_cmd_cb */ 5169 nullptr /* set_doc */ 5170 }, 5171 5172 gdb::option::string_option_def<info_vars_funcs_options> { 5173 "t", 5174 [] (info_vars_funcs_options *opt) { return &opt->type_regexp; }, 5175 nullptr, /* show_cmd_cb */ 5176 nullptr /* set_doc */ 5177 } 5178}; 5179 5180/* Returns the option group used by 'info variables' and 'info 5181 functions'. */ 5182 5183static gdb::option::option_def_group 5184make_info_vars_funcs_options_def_group (info_vars_funcs_options *opts) 5185{ 5186 return {{info_vars_funcs_options_defs}, opts}; 5187} 5188 5189/* Command completer for 'info variables' and 'info functions'. */ 5190 5191static void 5192info_vars_funcs_command_completer (struct cmd_list_element *ignore, 5193 completion_tracker &tracker, 5194 const char *text, const char * /* word */) 5195{ 5196 const auto group 5197 = make_info_vars_funcs_options_def_group (nullptr); 5198 if (gdb::option::complete_options 5199 (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, group)) 5200 return; 5201 5202 const char *word = advance_to_expression_complete_word_point (tracker, text); 5203 symbol_completer (ignore, tracker, text, word); 5204} 5205 5206/* Implement the 'info variables' command. */ 5207 5208static void 5209info_variables_command (const char *args, int from_tty) 5210{ 5211 info_vars_funcs_options opts; 5212 auto grp = make_info_vars_funcs_options_def_group (&opts); 5213 gdb::option::process_options 5214 (&args, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, grp); 5215 if (args != nullptr && *args == '\0') 5216 args = nullptr; 5217 5218 symtab_symbol_info 5219 (opts.quiet, opts.exclude_minsyms, args, VARIABLES_DOMAIN, 5220 opts.type_regexp.empty () ? nullptr : opts.type_regexp.c_str (), 5221 from_tty); 5222} 5223 5224/* Implement the 'info functions' command. */ 5225 5226static void 5227info_functions_command (const char *args, int from_tty) 5228{ 5229 info_vars_funcs_options opts; 5230 5231 auto grp = make_info_vars_funcs_options_def_group (&opts); 5232 gdb::option::process_options 5233 (&args, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, grp); 5234 if (args != nullptr && *args == '\0') 5235 args = nullptr; 5236 5237 symtab_symbol_info 5238 (opts.quiet, opts.exclude_minsyms, args, FUNCTIONS_DOMAIN, 5239 opts.type_regexp.empty () ? nullptr : opts.type_regexp.c_str (), 5240 from_tty); 5241} 5242 5243/* Holds the -q option for the 'info types' command. */ 5244 5245struct info_types_options 5246{ 5247 bool quiet = false; 5248}; 5249 5250/* The options used by the 'info types' command. */ 5251 5252static const gdb::option::option_def info_types_options_defs[] = { 5253 gdb::option::boolean_option_def<info_types_options> { 5254 "q", 5255 [] (info_types_options *opt) { return &opt->quiet; }, 5256 nullptr, /* show_cmd_cb */ 5257 nullptr /* set_doc */ 5258 } 5259}; 5260 5261/* Returns the option group used by 'info types'. */ 5262 5263static gdb::option::option_def_group 5264make_info_types_options_def_group (info_types_options *opts) 5265{ 5266 return {{info_types_options_defs}, opts}; 5267} 5268 5269/* Implement the 'info types' command. */ 5270 5271static void 5272info_types_command (const char *args, int from_tty) 5273{ 5274 info_types_options opts; 5275 5276 auto grp = make_info_types_options_def_group (&opts); 5277 gdb::option::process_options 5278 (&args, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, grp); 5279 if (args != nullptr && *args == '\0') 5280 args = nullptr; 5281 symtab_symbol_info (opts.quiet, false, args, TYPES_DOMAIN, NULL, from_tty); 5282} 5283 5284/* Command completer for 'info types' command. */ 5285 5286static void 5287info_types_command_completer (struct cmd_list_element *ignore, 5288 completion_tracker &tracker, 5289 const char *text, const char * /* word */) 5290{ 5291 const auto group 5292 = make_info_types_options_def_group (nullptr); 5293 if (gdb::option::complete_options 5294 (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, group)) 5295 return; 5296 5297 const char *word = advance_to_expression_complete_word_point (tracker, text); 5298 symbol_completer (ignore, tracker, text, word); 5299} 5300 5301/* Implement the 'info modules' command. */ 5302 5303static void 5304info_modules_command (const char *args, int from_tty) 5305{ 5306 info_types_options opts; 5307 5308 auto grp = make_info_types_options_def_group (&opts); 5309 gdb::option::process_options 5310 (&args, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, grp); 5311 if (args != nullptr && *args == '\0') 5312 args = nullptr; 5313 symtab_symbol_info (opts.quiet, true, args, MODULES_DOMAIN, NULL, 5314 from_tty); 5315} 5316 5317static void 5318rbreak_command (const char *regexp, int from_tty) 5319{ 5320 std::string string; 5321 const char *file_name = nullptr; 5322 5323 if (regexp != nullptr) 5324 { 5325 const char *colon = strchr (regexp, ':'); 5326 5327 /* Ignore the colon if it is part of a Windows drive. */ 5328 if (HAS_DRIVE_SPEC (regexp) 5329 && (regexp[2] == '/' || regexp[2] == '\\')) 5330 colon = strchr (STRIP_DRIVE_SPEC (regexp), ':'); 5331 5332 if (colon && *(colon + 1) != ':') 5333 { 5334 int colon_index; 5335 char *local_name; 5336 5337 colon_index = colon - regexp; 5338 local_name = (char *) alloca (colon_index + 1); 5339 memcpy (local_name, regexp, colon_index); 5340 local_name[colon_index--] = 0; 5341 while (isspace (local_name[colon_index])) 5342 local_name[colon_index--] = 0; 5343 file_name = local_name; 5344 regexp = skip_spaces (colon + 1); 5345 } 5346 } 5347 5348 global_symbol_searcher spec (FUNCTIONS_DOMAIN, regexp); 5349 if (file_name != nullptr) 5350 spec.filenames.push_back (file_name); 5351 std::vector<symbol_search> symbols = spec.search (); 5352 5353 scoped_rbreak_breakpoints finalize; 5354 for (const symbol_search &p : symbols) 5355 { 5356 if (p.msymbol.minsym == NULL) 5357 { 5358 struct symtab *symtab = p.symbol->symtab (); 5359 const char *fullname = symtab_to_fullname (symtab); 5360 5361 string = string_printf ("%s:'%s'", fullname, 5362 p.symbol->linkage_name ()); 5363 break_command (&string[0], from_tty); 5364 print_symbol_info (FUNCTIONS_DOMAIN, p.symbol, p.block, NULL); 5365 } 5366 else 5367 { 5368 string = string_printf ("'%s'", 5369 p.msymbol.minsym->linkage_name ()); 5370 5371 break_command (&string[0], from_tty); 5372 gdb_printf ("<function, no debug info> %s;\n", 5373 p.msymbol.minsym->print_name ()); 5374 } 5375 } 5376} 5377 5378 5379/* Evaluate if SYMNAME matches LOOKUP_NAME. */ 5380 5381static int 5382compare_symbol_name (const char *symbol_name, language symbol_language, 5383 const lookup_name_info &lookup_name, 5384 completion_match_result &match_res) 5385{ 5386 const language_defn *lang = language_def (symbol_language); 5387 5388 symbol_name_matcher_ftype *name_match 5389 = lang->get_symbol_name_matcher (lookup_name); 5390 5391 return name_match (symbol_name, lookup_name, &match_res); 5392} 5393 5394/* See symtab.h. */ 5395 5396bool 5397completion_list_add_name (completion_tracker &tracker, 5398 language symbol_language, 5399 const char *symname, 5400 const lookup_name_info &lookup_name, 5401 const char *text, const char *word) 5402{ 5403 completion_match_result &match_res 5404 = tracker.reset_completion_match_result (); 5405 5406 /* Clip symbols that cannot match. */ 5407 if (!compare_symbol_name (symname, symbol_language, lookup_name, match_res)) 5408 return false; 5409 5410 /* Refresh SYMNAME from the match string. It's potentially 5411 different depending on language. (E.g., on Ada, the match may be 5412 the encoded symbol name wrapped in "<>"). */ 5413 symname = match_res.match.match (); 5414 gdb_assert (symname != NULL); 5415 5416 /* We have a match for a completion, so add SYMNAME to the current list 5417 of matches. Note that the name is moved to freshly malloc'd space. */ 5418 5419 { 5420 gdb::unique_xmalloc_ptr<char> completion 5421 = make_completion_match_str (symname, text, word); 5422 5423 /* Here we pass the match-for-lcd object to add_completion. Some 5424 languages match the user text against substrings of symbol 5425 names in some cases. E.g., in C++, "b push_ba" completes to 5426 "std::vector::push_back", "std::string::push_back", etc., and 5427 in this case we want the completion lowest common denominator 5428 to be "push_back" instead of "std::". */ 5429 tracker.add_completion (std::move (completion), 5430 &match_res.match_for_lcd, text, word); 5431 } 5432 5433 return true; 5434} 5435 5436/* completion_list_add_name wrapper for struct symbol. */ 5437 5438static void 5439completion_list_add_symbol (completion_tracker &tracker, 5440 symbol *sym, 5441 const lookup_name_info &lookup_name, 5442 const char *text, const char *word) 5443{ 5444 if (!completion_list_add_name (tracker, sym->language (), 5445 sym->natural_name (), 5446 lookup_name, text, word)) 5447 return; 5448 5449 /* C++ function symbols include the parameters within both the msymbol 5450 name and the symbol name. The problem is that the msymbol name will 5451 describe the parameters in the most basic way, with typedefs stripped 5452 out, while the symbol name will represent the types as they appear in 5453 the program. This means we will see duplicate entries in the 5454 completion tracker. The following converts the symbol name back to 5455 the msymbol name and removes the msymbol name from the completion 5456 tracker. */ 5457 if (sym->language () == language_cplus 5458 && sym->domain () == VAR_DOMAIN 5459 && sym->aclass () == LOC_BLOCK) 5460 { 5461 /* The call to canonicalize returns the empty string if the input 5462 string is already in canonical form, thanks to this we don't 5463 remove the symbol we just added above. */ 5464 gdb::unique_xmalloc_ptr<char> str 5465 = cp_canonicalize_string_no_typedefs (sym->natural_name ()); 5466 if (str != nullptr) 5467 tracker.remove_completion (str.get ()); 5468 } 5469} 5470 5471/* completion_list_add_name wrapper for struct minimal_symbol. */ 5472 5473static void 5474completion_list_add_msymbol (completion_tracker &tracker, 5475 minimal_symbol *sym, 5476 const lookup_name_info &lookup_name, 5477 const char *text, const char *word) 5478{ 5479 completion_list_add_name (tracker, sym->language (), 5480 sym->natural_name (), 5481 lookup_name, text, word); 5482} 5483 5484 5485/* ObjC: In case we are completing on a selector, look as the msymbol 5486 again and feed all the selectors into the mill. */ 5487 5488static void 5489completion_list_objc_symbol (completion_tracker &tracker, 5490 struct minimal_symbol *msymbol, 5491 const lookup_name_info &lookup_name, 5492 const char *text, const char *word) 5493{ 5494 static char *tmp = NULL; 5495 static unsigned int tmplen = 0; 5496 5497 const char *method, *category, *selector; 5498 char *tmp2 = NULL; 5499 5500 method = msymbol->natural_name (); 5501 5502 /* Is it a method? */ 5503 if ((method[0] != '-') && (method[0] != '+')) 5504 return; 5505 5506 if (text[0] == '[') 5507 /* Complete on shortened method method. */ 5508 completion_list_add_name (tracker, language_objc, 5509 method + 1, 5510 lookup_name, 5511 text, word); 5512 5513 while ((strlen (method) + 1) >= tmplen) 5514 { 5515 if (tmplen == 0) 5516 tmplen = 1024; 5517 else 5518 tmplen *= 2; 5519 tmp = (char *) xrealloc (tmp, tmplen); 5520 } 5521 selector = strchr (method, ' '); 5522 if (selector != NULL) 5523 selector++; 5524 5525 category = strchr (method, '('); 5526 5527 if ((category != NULL) && (selector != NULL)) 5528 { 5529 memcpy (tmp, method, (category - method)); 5530 tmp[category - method] = ' '; 5531 memcpy (tmp + (category - method) + 1, selector, strlen (selector) + 1); 5532 completion_list_add_name (tracker, language_objc, tmp, 5533 lookup_name, text, word); 5534 if (text[0] == '[') 5535 completion_list_add_name (tracker, language_objc, tmp + 1, 5536 lookup_name, text, word); 5537 } 5538 5539 if (selector != NULL) 5540 { 5541 /* Complete on selector only. */ 5542 strcpy (tmp, selector); 5543 tmp2 = strchr (tmp, ']'); 5544 if (tmp2 != NULL) 5545 *tmp2 = '\0'; 5546 5547 completion_list_add_name (tracker, language_objc, tmp, 5548 lookup_name, text, word); 5549 } 5550} 5551 5552/* Break the non-quoted text based on the characters which are in 5553 symbols. FIXME: This should probably be language-specific. */ 5554 5555static const char * 5556language_search_unquoted_string (const char *text, const char *p) 5557{ 5558 for (; p > text; --p) 5559 { 5560 if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0') 5561 continue; 5562 else 5563 { 5564 if ((current_language->la_language == language_objc)) 5565 { 5566 if (p[-1] == ':') /* Might be part of a method name. */ 5567 continue; 5568 else if (p[-1] == '[' && (p[-2] == '-' || p[-2] == '+')) 5569 p -= 2; /* Beginning of a method name. */ 5570 else if (p[-1] == ' ' || p[-1] == '(' || p[-1] == ')') 5571 { /* Might be part of a method name. */ 5572 const char *t = p; 5573 5574 /* Seeing a ' ' or a '(' is not conclusive evidence 5575 that we are in the middle of a method name. However, 5576 finding "-[" or "+[" should be pretty un-ambiguous. 5577 Unfortunately we have to find it now to decide. */ 5578 5579 while (t > text) 5580 if (isalnum (t[-1]) || t[-1] == '_' || 5581 t[-1] == ' ' || t[-1] == ':' || 5582 t[-1] == '(' || t[-1] == ')') 5583 --t; 5584 else 5585 break; 5586 5587 if (t[-1] == '[' && (t[-2] == '-' || t[-2] == '+')) 5588 p = t - 2; /* Method name detected. */ 5589 /* Else we leave with p unchanged. */ 5590 } 5591 } 5592 break; 5593 } 5594 } 5595 return p; 5596} 5597 5598static void 5599completion_list_add_fields (completion_tracker &tracker, 5600 struct symbol *sym, 5601 const lookup_name_info &lookup_name, 5602 const char *text, const char *word) 5603{ 5604 if (sym->aclass () == LOC_TYPEDEF) 5605 { 5606 struct type *t = sym->type (); 5607 enum type_code c = t->code (); 5608 int j; 5609 5610 if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT) 5611 for (j = TYPE_N_BASECLASSES (t); j < t->num_fields (); j++) 5612 if (t->field (j).name ()) 5613 completion_list_add_name (tracker, sym->language (), 5614 t->field (j).name (), 5615 lookup_name, text, word); 5616 } 5617} 5618 5619/* See symtab.h. */ 5620 5621bool 5622symbol_is_function_or_method (symbol *sym) 5623{ 5624 switch (sym->type ()->code ()) 5625 { 5626 case TYPE_CODE_FUNC: 5627 case TYPE_CODE_METHOD: 5628 return true; 5629 default: 5630 return false; 5631 } 5632} 5633 5634/* See symtab.h. */ 5635 5636bool 5637symbol_is_function_or_method (minimal_symbol *msymbol) 5638{ 5639 switch (msymbol->type ()) 5640 { 5641 case mst_text: 5642 case mst_text_gnu_ifunc: 5643 case mst_solib_trampoline: 5644 case mst_file_text: 5645 return true; 5646 default: 5647 return false; 5648 } 5649} 5650 5651/* See symtab.h. */ 5652 5653bound_minimal_symbol 5654find_gnu_ifunc (const symbol *sym) 5655{ 5656 if (sym->aclass () != LOC_BLOCK) 5657 return {}; 5658 5659 lookup_name_info lookup_name (sym->search_name (), 5660 symbol_name_match_type::SEARCH_NAME); 5661 struct objfile *objfile = sym->objfile (); 5662 5663 CORE_ADDR address = sym->value_block ()->entry_pc (); 5664 minimal_symbol *ifunc = NULL; 5665 5666 iterate_over_minimal_symbols (objfile, lookup_name, 5667 [&] (minimal_symbol *minsym) 5668 { 5669 if (minsym->type () == mst_text_gnu_ifunc 5670 || minsym->type () == mst_data_gnu_ifunc) 5671 { 5672 CORE_ADDR msym_addr = minsym->value_address (objfile); 5673 if (minsym->type () == mst_data_gnu_ifunc) 5674 { 5675 struct gdbarch *gdbarch = objfile->arch (); 5676 msym_addr = gdbarch_convert_from_func_ptr_addr 5677 (gdbarch, msym_addr, current_inferior ()->top_target ()); 5678 } 5679 if (msym_addr == address) 5680 { 5681 ifunc = minsym; 5682 return true; 5683 } 5684 } 5685 return false; 5686 }); 5687 5688 if (ifunc != NULL) 5689 return {ifunc, objfile}; 5690 return {}; 5691} 5692 5693/* Add matching symbols from SYMTAB to the current completion list. */ 5694 5695static void 5696add_symtab_completions (struct compunit_symtab *cust, 5697 completion_tracker &tracker, 5698 complete_symbol_mode mode, 5699 const lookup_name_info &lookup_name, 5700 const char *text, const char *word, 5701 enum type_code code) 5702{ 5703 struct symbol *sym; 5704 struct block_iterator iter; 5705 int i; 5706 5707 if (cust == NULL) 5708 return; 5709 5710 for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++) 5711 { 5712 QUIT; 5713 5714 const struct block *b = cust->blockvector ()->block (i); 5715 ALL_BLOCK_SYMBOLS (b, iter, sym) 5716 { 5717 if (completion_skip_symbol (mode, sym)) 5718 continue; 5719 5720 if (code == TYPE_CODE_UNDEF 5721 || (sym->domain () == STRUCT_DOMAIN 5722 && sym->type ()->code () == code)) 5723 completion_list_add_symbol (tracker, sym, 5724 lookup_name, 5725 text, word); 5726 } 5727 } 5728} 5729 5730void 5731default_collect_symbol_completion_matches_break_on 5732 (completion_tracker &tracker, complete_symbol_mode mode, 5733 symbol_name_match_type name_match_type, 5734 const char *text, const char *word, 5735 const char *break_on, enum type_code code) 5736{ 5737 /* Problem: All of the symbols have to be copied because readline 5738 frees them. I'm not going to worry about this; hopefully there 5739 won't be that many. */ 5740 5741 struct symbol *sym; 5742 const struct block *b; 5743 const struct block *surrounding_static_block, *surrounding_global_block; 5744 struct block_iterator iter; 5745 /* The symbol we are completing on. Points in same buffer as text. */ 5746 const char *sym_text; 5747 5748 /* Now look for the symbol we are supposed to complete on. */ 5749 if (mode == complete_symbol_mode::LINESPEC) 5750 sym_text = text; 5751 else 5752 { 5753 const char *p; 5754 char quote_found; 5755 const char *quote_pos = NULL; 5756 5757 /* First see if this is a quoted string. */ 5758 quote_found = '\0'; 5759 for (p = text; *p != '\0'; ++p) 5760 { 5761 if (quote_found != '\0') 5762 { 5763 if (*p == quote_found) 5764 /* Found close quote. */ 5765 quote_found = '\0'; 5766 else if (*p == '\\' && p[1] == quote_found) 5767 /* A backslash followed by the quote character 5768 doesn't end the string. */ 5769 ++p; 5770 } 5771 else if (*p == '\'' || *p == '"') 5772 { 5773 quote_found = *p; 5774 quote_pos = p; 5775 } 5776 } 5777 if (quote_found == '\'') 5778 /* A string within single quotes can be a symbol, so complete on it. */ 5779 sym_text = quote_pos + 1; 5780 else if (quote_found == '"') 5781 /* A double-quoted string is never a symbol, nor does it make sense 5782 to complete it any other way. */ 5783 { 5784 return; 5785 } 5786 else 5787 { 5788 /* It is not a quoted string. Break it based on the characters 5789 which are in symbols. */ 5790 while (p > text) 5791 { 5792 if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0' 5793 || p[-1] == ':' || strchr (break_on, p[-1]) != NULL) 5794 --p; 5795 else 5796 break; 5797 } 5798 sym_text = p; 5799 } 5800 } 5801 5802 lookup_name_info lookup_name (sym_text, name_match_type, true); 5803 5804 /* At this point scan through the misc symbol vectors and add each 5805 symbol you find to the list. Eventually we want to ignore 5806 anything that isn't a text symbol (everything else will be 5807 handled by the psymtab code below). */ 5808 5809 if (code == TYPE_CODE_UNDEF) 5810 { 5811 for (objfile *objfile : current_program_space->objfiles ()) 5812 { 5813 for (minimal_symbol *msymbol : objfile->msymbols ()) 5814 { 5815 QUIT; 5816 5817 if (completion_skip_symbol (mode, msymbol)) 5818 continue; 5819 5820 completion_list_add_msymbol (tracker, msymbol, lookup_name, 5821 sym_text, word); 5822 5823 completion_list_objc_symbol (tracker, msymbol, lookup_name, 5824 sym_text, word); 5825 } 5826 } 5827 } 5828 5829 /* Add completions for all currently loaded symbol tables. */ 5830 for (objfile *objfile : current_program_space->objfiles ()) 5831 { 5832 for (compunit_symtab *cust : objfile->compunits ()) 5833 add_symtab_completions (cust, tracker, mode, lookup_name, 5834 sym_text, word, code); 5835 } 5836 5837 /* Look through the partial symtabs for all symbols which begin by 5838 matching SYM_TEXT. Expand all CUs that you find to the list. */ 5839 expand_symtabs_matching (NULL, 5840 lookup_name, 5841 NULL, 5842 [&] (compunit_symtab *symtab) /* expansion notify */ 5843 { 5844 add_symtab_completions (symtab, 5845 tracker, mode, lookup_name, 5846 sym_text, word, code); 5847 return true; 5848 }, 5849 SEARCH_GLOBAL_BLOCK | SEARCH_STATIC_BLOCK, 5850 ALL_DOMAIN); 5851 5852 /* Search upwards from currently selected frame (so that we can 5853 complete on local vars). Also catch fields of types defined in 5854 this places which match our text string. Only complete on types 5855 visible from current context. */ 5856 5857 b = get_selected_block (0); 5858 surrounding_static_block = block_static_block (b); 5859 surrounding_global_block = block_global_block (b); 5860 if (surrounding_static_block != NULL) 5861 while (b != surrounding_static_block) 5862 { 5863 QUIT; 5864 5865 ALL_BLOCK_SYMBOLS (b, iter, sym) 5866 { 5867 if (code == TYPE_CODE_UNDEF) 5868 { 5869 completion_list_add_symbol (tracker, sym, lookup_name, 5870 sym_text, word); 5871 completion_list_add_fields (tracker, sym, lookup_name, 5872 sym_text, word); 5873 } 5874 else if (sym->domain () == STRUCT_DOMAIN 5875 && sym->type ()->code () == code) 5876 completion_list_add_symbol (tracker, sym, lookup_name, 5877 sym_text, word); 5878 } 5879 5880 /* Stop when we encounter an enclosing function. Do not stop for 5881 non-inlined functions - the locals of the enclosing function 5882 are in scope for a nested function. */ 5883 if (b->function () != NULL && block_inlined_p (b)) 5884 break; 5885 b = b->superblock (); 5886 } 5887 5888 /* Add fields from the file's types; symbols will be added below. */ 5889 5890 if (code == TYPE_CODE_UNDEF) 5891 { 5892 if (surrounding_static_block != NULL) 5893 ALL_BLOCK_SYMBOLS (surrounding_static_block, iter, sym) 5894 completion_list_add_fields (tracker, sym, lookup_name, 5895 sym_text, word); 5896 5897 if (surrounding_global_block != NULL) 5898 ALL_BLOCK_SYMBOLS (surrounding_global_block, iter, sym) 5899 completion_list_add_fields (tracker, sym, lookup_name, 5900 sym_text, word); 5901 } 5902 5903 /* Skip macros if we are completing a struct tag -- arguable but 5904 usually what is expected. */ 5905 if (current_language->macro_expansion () == macro_expansion_c 5906 && code == TYPE_CODE_UNDEF) 5907 { 5908 gdb::unique_xmalloc_ptr<struct macro_scope> scope; 5909 5910 /* This adds a macro's name to the current completion list. */ 5911 auto add_macro_name = [&] (const char *macro_name, 5912 const macro_definition *, 5913 macro_source_file *, 5914 int) 5915 { 5916 completion_list_add_name (tracker, language_c, macro_name, 5917 lookup_name, sym_text, word); 5918 }; 5919 5920 /* Add any macros visible in the default scope. Note that this 5921 may yield the occasional wrong result, because an expression 5922 might be evaluated in a scope other than the default. For 5923 example, if the user types "break file:line if <TAB>", the 5924 resulting expression will be evaluated at "file:line" -- but 5925 at there does not seem to be a way to detect this at 5926 completion time. */ 5927 scope = default_macro_scope (); 5928 if (scope) 5929 macro_for_each_in_scope (scope->file, scope->line, 5930 add_macro_name); 5931 5932 /* User-defined macros are always visible. */ 5933 macro_for_each (macro_user_macros, add_macro_name); 5934 } 5935} 5936 5937/* Collect all symbols (regardless of class) which begin by matching 5938 TEXT. */ 5939 5940void 5941collect_symbol_completion_matches (completion_tracker &tracker, 5942 complete_symbol_mode mode, 5943 symbol_name_match_type name_match_type, 5944 const char *text, const char *word) 5945{ 5946 current_language->collect_symbol_completion_matches (tracker, mode, 5947 name_match_type, 5948 text, word, 5949 TYPE_CODE_UNDEF); 5950} 5951 5952/* Like collect_symbol_completion_matches, but only collect 5953 STRUCT_DOMAIN symbols whose type code is CODE. */ 5954 5955void 5956collect_symbol_completion_matches_type (completion_tracker &tracker, 5957 const char *text, const char *word, 5958 enum type_code code) 5959{ 5960 complete_symbol_mode mode = complete_symbol_mode::EXPRESSION; 5961 symbol_name_match_type name_match_type = symbol_name_match_type::EXPRESSION; 5962 5963 gdb_assert (code == TYPE_CODE_UNION 5964 || code == TYPE_CODE_STRUCT 5965 || code == TYPE_CODE_ENUM); 5966 current_language->collect_symbol_completion_matches (tracker, mode, 5967 name_match_type, 5968 text, word, code); 5969} 5970 5971/* Like collect_symbol_completion_matches, but collects a list of 5972 symbols defined in all source files named SRCFILE. */ 5973 5974void 5975collect_file_symbol_completion_matches (completion_tracker &tracker, 5976 complete_symbol_mode mode, 5977 symbol_name_match_type name_match_type, 5978 const char *text, const char *word, 5979 const char *srcfile) 5980{ 5981 /* The symbol we are completing on. Points in same buffer as text. */ 5982 const char *sym_text; 5983 5984 /* Now look for the symbol we are supposed to complete on. 5985 FIXME: This should be language-specific. */ 5986 if (mode == complete_symbol_mode::LINESPEC) 5987 sym_text = text; 5988 else 5989 { 5990 const char *p; 5991 char quote_found; 5992 const char *quote_pos = NULL; 5993 5994 /* First see if this is a quoted string. */ 5995 quote_found = '\0'; 5996 for (p = text; *p != '\0'; ++p) 5997 { 5998 if (quote_found != '\0') 5999 { 6000 if (*p == quote_found) 6001 /* Found close quote. */ 6002 quote_found = '\0'; 6003 else if (*p == '\\' && p[1] == quote_found) 6004 /* A backslash followed by the quote character 6005 doesn't end the string. */ 6006 ++p; 6007 } 6008 else if (*p == '\'' || *p == '"') 6009 { 6010 quote_found = *p; 6011 quote_pos = p; 6012 } 6013 } 6014 if (quote_found == '\'') 6015 /* A string within single quotes can be a symbol, so complete on it. */ 6016 sym_text = quote_pos + 1; 6017 else if (quote_found == '"') 6018 /* A double-quoted string is never a symbol, nor does it make sense 6019 to complete it any other way. */ 6020 { 6021 return; 6022 } 6023 else 6024 { 6025 /* Not a quoted string. */ 6026 sym_text = language_search_unquoted_string (text, p); 6027 } 6028 } 6029 6030 lookup_name_info lookup_name (sym_text, name_match_type, true); 6031 6032 /* Go through symtabs for SRCFILE and check the externs and statics 6033 for symbols which match. */ 6034 iterate_over_symtabs (srcfile, [&] (symtab *s) 6035 { 6036 add_symtab_completions (s->compunit (), 6037 tracker, mode, lookup_name, 6038 sym_text, word, TYPE_CODE_UNDEF); 6039 return false; 6040 }); 6041} 6042 6043/* A helper function for make_source_files_completion_list. It adds 6044 another file name to a list of possible completions, growing the 6045 list as necessary. */ 6046 6047static void 6048add_filename_to_list (const char *fname, const char *text, const char *word, 6049 completion_list *list) 6050{ 6051 list->emplace_back (make_completion_match_str (fname, text, word)); 6052} 6053 6054static int 6055not_interesting_fname (const char *fname) 6056{ 6057 static const char *illegal_aliens[] = { 6058 "_globals_", /* inserted by coff_symtab_read */ 6059 NULL 6060 }; 6061 int i; 6062 6063 for (i = 0; illegal_aliens[i]; i++) 6064 { 6065 if (filename_cmp (fname, illegal_aliens[i]) == 0) 6066 return 1; 6067 } 6068 return 0; 6069} 6070 6071/* An object of this type is passed as the callback argument to 6072 map_partial_symbol_filenames. */ 6073struct add_partial_filename_data 6074{ 6075 struct filename_seen_cache *filename_seen_cache; 6076 const char *text; 6077 const char *word; 6078 int text_len; 6079 completion_list *list; 6080 6081 void operator() (const char *filename, const char *fullname); 6082}; 6083 6084/* A callback for map_partial_symbol_filenames. */ 6085 6086void 6087add_partial_filename_data::operator() (const char *filename, 6088 const char *fullname) 6089{ 6090 if (not_interesting_fname (filename)) 6091 return; 6092 if (!filename_seen_cache->seen (filename) 6093 && filename_ncmp (filename, text, text_len) == 0) 6094 { 6095 /* This file matches for a completion; add it to the 6096 current list of matches. */ 6097 add_filename_to_list (filename, text, word, list); 6098 } 6099 else 6100 { 6101 const char *base_name = lbasename (filename); 6102 6103 if (base_name != filename 6104 && !filename_seen_cache->seen (base_name) 6105 && filename_ncmp (base_name, text, text_len) == 0) 6106 add_filename_to_list (base_name, text, word, list); 6107 } 6108} 6109 6110/* Return a list of all source files whose names begin with matching 6111 TEXT. The file names are looked up in the symbol tables of this 6112 program. */ 6113 6114completion_list 6115make_source_files_completion_list (const char *text, const char *word) 6116{ 6117 size_t text_len = strlen (text); 6118 completion_list list; 6119 const char *base_name; 6120 struct add_partial_filename_data datum; 6121 6122 if (!have_full_symbols () && !have_partial_symbols ()) 6123 return list; 6124 6125 filename_seen_cache filenames_seen; 6126 6127 for (objfile *objfile : current_program_space->objfiles ()) 6128 { 6129 for (compunit_symtab *cu : objfile->compunits ()) 6130 { 6131 for (symtab *s : cu->filetabs ()) 6132 { 6133 if (not_interesting_fname (s->filename)) 6134 continue; 6135 if (!filenames_seen.seen (s->filename) 6136 && filename_ncmp (s->filename, text, text_len) == 0) 6137 { 6138 /* This file matches for a completion; add it to the current 6139 list of matches. */ 6140 add_filename_to_list (s->filename, text, word, &list); 6141 } 6142 else 6143 { 6144 /* NOTE: We allow the user to type a base name when the 6145 debug info records leading directories, but not the other 6146 way around. This is what subroutines of breakpoint 6147 command do when they parse file names. */ 6148 base_name = lbasename (s->filename); 6149 if (base_name != s->filename 6150 && !filenames_seen.seen (base_name) 6151 && filename_ncmp (base_name, text, text_len) == 0) 6152 add_filename_to_list (base_name, text, word, &list); 6153 } 6154 } 6155 } 6156 } 6157 6158 datum.filename_seen_cache = &filenames_seen; 6159 datum.text = text; 6160 datum.word = word; 6161 datum.text_len = text_len; 6162 datum.list = &list; 6163 map_symbol_filenames (datum, false /*need_fullname*/); 6164 6165 return list; 6166} 6167 6168/* Track MAIN */ 6169 6170/* Return the "main_info" object for the current program space. If 6171 the object has not yet been created, create it and fill in some 6172 default values. */ 6173 6174static struct main_info * 6175get_main_info (void) 6176{ 6177 struct main_info *info = main_progspace_key.get (current_program_space); 6178 6179 if (info == NULL) 6180 { 6181 /* It may seem strange to store the main name in the progspace 6182 and also in whatever objfile happens to see a main name in 6183 its debug info. The reason for this is mainly historical: 6184 gdb returned "main" as the name even if no function named 6185 "main" was defined the program; and this approach lets us 6186 keep compatibility. */ 6187 info = main_progspace_key.emplace (current_program_space); 6188 } 6189 6190 return info; 6191} 6192 6193static void 6194set_main_name (const char *name, enum language lang) 6195{ 6196 struct main_info *info = get_main_info (); 6197 6198 if (info->name_of_main != NULL) 6199 { 6200 xfree (info->name_of_main); 6201 info->name_of_main = NULL; 6202 info->language_of_main = language_unknown; 6203 } 6204 if (name != NULL) 6205 { 6206 info->name_of_main = xstrdup (name); 6207 info->language_of_main = lang; 6208 } 6209} 6210 6211/* Deduce the name of the main procedure, and set NAME_OF_MAIN 6212 accordingly. */ 6213 6214static void 6215find_main_name (void) 6216{ 6217 const char *new_main_name; 6218 6219 /* First check the objfiles to see whether a debuginfo reader has 6220 picked up the appropriate main name. Historically the main name 6221 was found in a more or less random way; this approach instead 6222 relies on the order of objfile creation -- which still isn't 6223 guaranteed to get the correct answer, but is just probably more 6224 accurate. */ 6225 for (objfile *objfile : current_program_space->objfiles ()) 6226 { 6227 if (objfile->per_bfd->name_of_main != NULL) 6228 { 6229 set_main_name (objfile->per_bfd->name_of_main, 6230 objfile->per_bfd->language_of_main); 6231 return; 6232 } 6233 } 6234 6235 /* Try to see if the main procedure is in Ada. */ 6236 /* FIXME: brobecker/2005-03-07: Another way of doing this would 6237 be to add a new method in the language vector, and call this 6238 method for each language until one of them returns a non-empty 6239 name. This would allow us to remove this hard-coded call to 6240 an Ada function. It is not clear that this is a better approach 6241 at this point, because all methods need to be written in a way 6242 such that false positives never be returned. For instance, it is 6243 important that a method does not return a wrong name for the main 6244 procedure if the main procedure is actually written in a different 6245 language. It is easy to guaranty this with Ada, since we use a 6246 special symbol generated only when the main in Ada to find the name 6247 of the main procedure. It is difficult however to see how this can 6248 be guarantied for languages such as C, for instance. This suggests 6249 that order of call for these methods becomes important, which means 6250 a more complicated approach. */ 6251 new_main_name = ada_main_name (); 6252 if (new_main_name != NULL) 6253 { 6254 set_main_name (new_main_name, language_ada); 6255 return; 6256 } 6257 6258 new_main_name = d_main_name (); 6259 if (new_main_name != NULL) 6260 { 6261 set_main_name (new_main_name, language_d); 6262 return; 6263 } 6264 6265 new_main_name = go_main_name (); 6266 if (new_main_name != NULL) 6267 { 6268 set_main_name (new_main_name, language_go); 6269 return; 6270 } 6271 6272 new_main_name = pascal_main_name (); 6273 if (new_main_name != NULL) 6274 { 6275 set_main_name (new_main_name, language_pascal); 6276 return; 6277 } 6278 6279 /* The languages above didn't identify the name of the main procedure. 6280 Fallback to "main". */ 6281 6282 /* Try to find language for main in psymtabs. */ 6283 bool symbol_found_p = false; 6284 gdbarch_iterate_over_objfiles_in_search_order 6285 (target_gdbarch (), 6286 [&symbol_found_p] (objfile *obj) 6287 { 6288 language lang 6289 = obj->lookup_global_symbol_language ("main", VAR_DOMAIN, 6290 &symbol_found_p); 6291 if (symbol_found_p) 6292 { 6293 set_main_name ("main", lang); 6294 return 1; 6295 } 6296 6297 return 0; 6298 }, nullptr); 6299 6300 if (symbol_found_p) 6301 return; 6302 6303 set_main_name ("main", language_unknown); 6304} 6305 6306/* See symtab.h. */ 6307 6308const char * 6309main_name () 6310{ 6311 struct main_info *info = get_main_info (); 6312 6313 if (info->name_of_main == NULL) 6314 find_main_name (); 6315 6316 return info->name_of_main; 6317} 6318 6319/* Return the language of the main function. If it is not known, 6320 return language_unknown. */ 6321 6322enum language 6323main_language (void) 6324{ 6325 struct main_info *info = get_main_info (); 6326 6327 if (info->name_of_main == NULL) 6328 find_main_name (); 6329 6330 return info->language_of_main; 6331} 6332 6333/* Handle ``executable_changed'' events for the symtab module. */ 6334 6335static void 6336symtab_observer_executable_changed (void) 6337{ 6338 /* NAME_OF_MAIN may no longer be the same, so reset it for now. */ 6339 set_main_name (NULL, language_unknown); 6340} 6341 6342/* Return 1 if the supplied producer string matches the ARM RealView 6343 compiler (armcc). */ 6344 6345bool 6346producer_is_realview (const char *producer) 6347{ 6348 static const char *const arm_idents[] = { 6349 "ARM C Compiler, ADS", 6350 "Thumb C Compiler, ADS", 6351 "ARM C++ Compiler, ADS", 6352 "Thumb C++ Compiler, ADS", 6353 "ARM/Thumb C/C++ Compiler, RVCT", 6354 "ARM C/C++ Compiler, RVCT" 6355 }; 6356 6357 if (producer == NULL) 6358 return false; 6359 6360 for (const char *ident : arm_idents) 6361 if (startswith (producer, ident)) 6362 return true; 6363 6364 return false; 6365} 6366 6367 6368 6369/* The next index to hand out in response to a registration request. */ 6370 6371static int next_aclass_value = LOC_FINAL_VALUE; 6372 6373/* The maximum number of "aclass" registrations we support. This is 6374 constant for convenience. */ 6375#define MAX_SYMBOL_IMPLS (LOC_FINAL_VALUE + 10) 6376 6377/* The objects representing the various "aclass" values. The elements 6378 from 0 up to LOC_FINAL_VALUE-1 represent themselves, and subsequent 6379 elements are those registered at gdb initialization time. */ 6380 6381static struct symbol_impl symbol_impl[MAX_SYMBOL_IMPLS]; 6382 6383/* The globally visible pointer. This is separate from 'symbol_impl' 6384 so that it can be const. */ 6385 6386gdb::array_view<const struct symbol_impl> symbol_impls (symbol_impl); 6387 6388/* Make sure we saved enough room in struct symbol. */ 6389 6390gdb_static_assert (MAX_SYMBOL_IMPLS <= (1 << SYMBOL_ACLASS_BITS)); 6391 6392/* Register a computed symbol type. ACLASS must be LOC_COMPUTED. OPS 6393 is the ops vector associated with this index. This returns the new 6394 index, which should be used as the aclass_index field for symbols 6395 of this type. */ 6396 6397int 6398register_symbol_computed_impl (enum address_class aclass, 6399 const struct symbol_computed_ops *ops) 6400{ 6401 int result = next_aclass_value++; 6402 6403 gdb_assert (aclass == LOC_COMPUTED); 6404 gdb_assert (result < MAX_SYMBOL_IMPLS); 6405 symbol_impl[result].aclass = aclass; 6406 symbol_impl[result].ops_computed = ops; 6407 6408 /* Sanity check OPS. */ 6409 gdb_assert (ops != NULL); 6410 gdb_assert (ops->tracepoint_var_ref != NULL); 6411 gdb_assert (ops->describe_location != NULL); 6412 gdb_assert (ops->get_symbol_read_needs != NULL); 6413 gdb_assert (ops->read_variable != NULL); 6414 6415 return result; 6416} 6417 6418/* Register a function with frame base type. ACLASS must be LOC_BLOCK. 6419 OPS is the ops vector associated with this index. This returns the 6420 new index, which should be used as the aclass_index field for symbols 6421 of this type. */ 6422 6423int 6424register_symbol_block_impl (enum address_class aclass, 6425 const struct symbol_block_ops *ops) 6426{ 6427 int result = next_aclass_value++; 6428 6429 gdb_assert (aclass == LOC_BLOCK); 6430 gdb_assert (result < MAX_SYMBOL_IMPLS); 6431 symbol_impl[result].aclass = aclass; 6432 symbol_impl[result].ops_block = ops; 6433 6434 /* Sanity check OPS. */ 6435 gdb_assert (ops != NULL); 6436 gdb_assert (ops->find_frame_base_location != NULL); 6437 6438 return result; 6439} 6440 6441/* Register a register symbol type. ACLASS must be LOC_REGISTER or 6442 LOC_REGPARM_ADDR. OPS is the register ops vector associated with 6443 this index. This returns the new index, which should be used as 6444 the aclass_index field for symbols of this type. */ 6445 6446int 6447register_symbol_register_impl (enum address_class aclass, 6448 const struct symbol_register_ops *ops) 6449{ 6450 int result = next_aclass_value++; 6451 6452 gdb_assert (aclass == LOC_REGISTER || aclass == LOC_REGPARM_ADDR); 6453 gdb_assert (result < MAX_SYMBOL_IMPLS); 6454 symbol_impl[result].aclass = aclass; 6455 symbol_impl[result].ops_register = ops; 6456 6457 return result; 6458} 6459 6460/* Initialize elements of 'symbol_impl' for the constants in enum 6461 address_class. */ 6462 6463static void 6464initialize_ordinary_address_classes (void) 6465{ 6466 int i; 6467 6468 for (i = 0; i < LOC_FINAL_VALUE; ++i) 6469 symbol_impl[i].aclass = (enum address_class) i; 6470} 6471 6472 6473 6474/* See symtab.h. */ 6475 6476struct objfile * 6477symbol::objfile () const 6478{ 6479 gdb_assert (is_objfile_owned ()); 6480 return owner.symtab->compunit ()->objfile (); 6481} 6482 6483/* See symtab.h. */ 6484 6485struct gdbarch * 6486symbol::arch () const 6487{ 6488 if (!is_objfile_owned ()) 6489 return owner.arch; 6490 return owner.symtab->compunit ()->objfile ()->arch (); 6491} 6492 6493/* See symtab.h. */ 6494 6495struct symtab * 6496symbol::symtab () const 6497{ 6498 gdb_assert (is_objfile_owned ()); 6499 return owner.symtab; 6500} 6501 6502/* See symtab.h. */ 6503 6504void 6505symbol::set_symtab (struct symtab *symtab) 6506{ 6507 gdb_assert (is_objfile_owned ()); 6508 owner.symtab = symtab; 6509} 6510 6511/* See symtab.h. */ 6512 6513CORE_ADDR 6514get_symbol_address (const struct symbol *sym) 6515{ 6516 gdb_assert (sym->maybe_copied); 6517 gdb_assert (sym->aclass () == LOC_STATIC); 6518 6519 const char *linkage_name = sym->linkage_name (); 6520 6521 for (objfile *objfile : current_program_space->objfiles ()) 6522 { 6523 if (objfile->separate_debug_objfile_backlink != nullptr) 6524 continue; 6525 6526 bound_minimal_symbol minsym 6527 = lookup_minimal_symbol_linkage (linkage_name, objfile); 6528 if (minsym.minsym != nullptr) 6529 return minsym.value_address (); 6530 } 6531 return sym->m_value.address; 6532} 6533 6534/* See symtab.h. */ 6535 6536CORE_ADDR 6537get_msymbol_address (struct objfile *objf, const struct minimal_symbol *minsym) 6538{ 6539 gdb_assert (minsym->maybe_copied); 6540 gdb_assert ((objf->flags & OBJF_MAINLINE) == 0); 6541 6542 const char *linkage_name = minsym->linkage_name (); 6543 6544 for (objfile *objfile : current_program_space->objfiles ()) 6545 { 6546 if (objfile->separate_debug_objfile_backlink == nullptr 6547 && (objfile->flags & OBJF_MAINLINE) != 0) 6548 { 6549 bound_minimal_symbol found 6550 = lookup_minimal_symbol_linkage (linkage_name, objfile); 6551 if (found.minsym != nullptr) 6552 return found.value_address (); 6553 } 6554 } 6555 return (minsym->m_value.address 6556 + objf->section_offsets[minsym->section_index ()]); 6557} 6558 6559 6560 6561/* Hold the sub-commands of 'info module'. */ 6562 6563static struct cmd_list_element *info_module_cmdlist = NULL; 6564 6565/* See symtab.h. */ 6566 6567std::vector<module_symbol_search> 6568search_module_symbols (const char *module_regexp, const char *regexp, 6569 const char *type_regexp, search_domain kind) 6570{ 6571 std::vector<module_symbol_search> results; 6572 6573 /* Search for all modules matching MODULE_REGEXP. */ 6574 global_symbol_searcher spec1 (MODULES_DOMAIN, module_regexp); 6575 spec1.set_exclude_minsyms (true); 6576 std::vector<symbol_search> modules = spec1.search (); 6577 6578 /* Now search for all symbols of the required KIND matching the required 6579 regular expressions. We figure out which ones are in which modules 6580 below. */ 6581 global_symbol_searcher spec2 (kind, regexp); 6582 spec2.set_symbol_type_regexp (type_regexp); 6583 spec2.set_exclude_minsyms (true); 6584 std::vector<symbol_search> symbols = spec2.search (); 6585 6586 /* Now iterate over all MODULES, checking to see which items from 6587 SYMBOLS are in each module. */ 6588 for (const symbol_search &p : modules) 6589 { 6590 QUIT; 6591 6592 /* This is a module. */ 6593 gdb_assert (p.symbol != nullptr); 6594 6595 std::string prefix = p.symbol->print_name (); 6596 prefix += "::"; 6597 6598 for (const symbol_search &q : symbols) 6599 { 6600 if (q.symbol == nullptr) 6601 continue; 6602 6603 if (strncmp (q.symbol->print_name (), prefix.c_str (), 6604 prefix.size ()) != 0) 6605 continue; 6606 6607 results.push_back ({p, q}); 6608 } 6609 } 6610 6611 return results; 6612} 6613 6614/* Implement the core of both 'info module functions' and 'info module 6615 variables'. */ 6616 6617static void 6618info_module_subcommand (bool quiet, const char *module_regexp, 6619 const char *regexp, const char *type_regexp, 6620 search_domain kind) 6621{ 6622 /* Print a header line. Don't build the header line bit by bit as this 6623 prevents internationalisation. */ 6624 if (!quiet) 6625 { 6626 if (module_regexp == nullptr) 6627 { 6628 if (type_regexp == nullptr) 6629 { 6630 if (regexp == nullptr) 6631 gdb_printf ((kind == VARIABLES_DOMAIN 6632 ? _("All variables in all modules:") 6633 : _("All functions in all modules:"))); 6634 else 6635 gdb_printf 6636 ((kind == VARIABLES_DOMAIN 6637 ? _("All variables matching regular expression" 6638 " \"%s\" in all modules:") 6639 : _("All functions matching regular expression" 6640 " \"%s\" in all modules:")), 6641 regexp); 6642 } 6643 else 6644 { 6645 if (regexp == nullptr) 6646 gdb_printf 6647 ((kind == VARIABLES_DOMAIN 6648 ? _("All variables with type matching regular " 6649 "expression \"%s\" in all modules:") 6650 : _("All functions with type matching regular " 6651 "expression \"%s\" in all modules:")), 6652 type_regexp); 6653 else 6654 gdb_printf 6655 ((kind == VARIABLES_DOMAIN 6656 ? _("All variables matching regular expression " 6657 "\"%s\",\n\twith type matching regular " 6658 "expression \"%s\" in all modules:") 6659 : _("All functions matching regular expression " 6660 "\"%s\",\n\twith type matching regular " 6661 "expression \"%s\" in all modules:")), 6662 regexp, type_regexp); 6663 } 6664 } 6665 else 6666 { 6667 if (type_regexp == nullptr) 6668 { 6669 if (regexp == nullptr) 6670 gdb_printf 6671 ((kind == VARIABLES_DOMAIN 6672 ? _("All variables in all modules matching regular " 6673 "expression \"%s\":") 6674 : _("All functions in all modules matching regular " 6675 "expression \"%s\":")), 6676 module_regexp); 6677 else 6678 gdb_printf 6679 ((kind == VARIABLES_DOMAIN 6680 ? _("All variables matching regular expression " 6681 "\"%s\",\n\tin all modules matching regular " 6682 "expression \"%s\":") 6683 : _("All functions matching regular expression " 6684 "\"%s\",\n\tin all modules matching regular " 6685 "expression \"%s\":")), 6686 regexp, module_regexp); 6687 } 6688 else 6689 { 6690 if (regexp == nullptr) 6691 gdb_printf 6692 ((kind == VARIABLES_DOMAIN 6693 ? _("All variables with type matching regular " 6694 "expression \"%s\"\n\tin all modules matching " 6695 "regular expression \"%s\":") 6696 : _("All functions with type matching regular " 6697 "expression \"%s\"\n\tin all modules matching " 6698 "regular expression \"%s\":")), 6699 type_regexp, module_regexp); 6700 else 6701 gdb_printf 6702 ((kind == VARIABLES_DOMAIN 6703 ? _("All variables matching regular expression " 6704 "\"%s\",\n\twith type matching regular expression " 6705 "\"%s\",\n\tin all modules matching regular " 6706 "expression \"%s\":") 6707 : _("All functions matching regular expression " 6708 "\"%s\",\n\twith type matching regular expression " 6709 "\"%s\",\n\tin all modules matching regular " 6710 "expression \"%s\":")), 6711 regexp, type_regexp, module_regexp); 6712 } 6713 } 6714 gdb_printf ("\n"); 6715 } 6716 6717 /* Find all symbols of type KIND matching the given regular expressions 6718 along with the symbols for the modules in which those symbols 6719 reside. */ 6720 std::vector<module_symbol_search> module_symbols 6721 = search_module_symbols (module_regexp, regexp, type_regexp, kind); 6722 6723 std::sort (module_symbols.begin (), module_symbols.end (), 6724 [] (const module_symbol_search &a, const module_symbol_search &b) 6725 { 6726 if (a.first < b.first) 6727 return true; 6728 else if (a.first == b.first) 6729 return a.second < b.second; 6730 else 6731 return false; 6732 }); 6733 6734 const char *last_filename = ""; 6735 const symbol *last_module_symbol = nullptr; 6736 for (const module_symbol_search &ms : module_symbols) 6737 { 6738 const symbol_search &p = ms.first; 6739 const symbol_search &q = ms.second; 6740 6741 gdb_assert (q.symbol != nullptr); 6742 6743 if (last_module_symbol != p.symbol) 6744 { 6745 gdb_printf ("\n"); 6746 gdb_printf (_("Module \"%s\":\n"), p.symbol->print_name ()); 6747 last_module_symbol = p.symbol; 6748 last_filename = ""; 6749 } 6750 6751 print_symbol_info (FUNCTIONS_DOMAIN, q.symbol, q.block, 6752 last_filename); 6753 last_filename 6754 = symtab_to_filename_for_display (q.symbol->symtab ()); 6755 } 6756} 6757 6758/* Hold the option values for the 'info module .....' sub-commands. */ 6759 6760struct info_modules_var_func_options 6761{ 6762 bool quiet = false; 6763 std::string type_regexp; 6764 std::string module_regexp; 6765}; 6766 6767/* The options used by 'info module variables' and 'info module functions' 6768 commands. */ 6769 6770static const gdb::option::option_def info_modules_var_func_options_defs [] = { 6771 gdb::option::boolean_option_def<info_modules_var_func_options> { 6772 "q", 6773 [] (info_modules_var_func_options *opt) { return &opt->quiet; }, 6774 nullptr, /* show_cmd_cb */ 6775 nullptr /* set_doc */ 6776 }, 6777 6778 gdb::option::string_option_def<info_modules_var_func_options> { 6779 "t", 6780 [] (info_modules_var_func_options *opt) { return &opt->type_regexp; }, 6781 nullptr, /* show_cmd_cb */ 6782 nullptr /* set_doc */ 6783 }, 6784 6785 gdb::option::string_option_def<info_modules_var_func_options> { 6786 "m", 6787 [] (info_modules_var_func_options *opt) { return &opt->module_regexp; }, 6788 nullptr, /* show_cmd_cb */ 6789 nullptr /* set_doc */ 6790 } 6791}; 6792 6793/* Return the option group used by the 'info module ...' sub-commands. */ 6794 6795static inline gdb::option::option_def_group 6796make_info_modules_var_func_options_def_group 6797 (info_modules_var_func_options *opts) 6798{ 6799 return {{info_modules_var_func_options_defs}, opts}; 6800} 6801 6802/* Implements the 'info module functions' command. */ 6803 6804static void 6805info_module_functions_command (const char *args, int from_tty) 6806{ 6807 info_modules_var_func_options opts; 6808 auto grp = make_info_modules_var_func_options_def_group (&opts); 6809 gdb::option::process_options 6810 (&args, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, grp); 6811 if (args != nullptr && *args == '\0') 6812 args = nullptr; 6813 6814 info_module_subcommand 6815 (opts.quiet, 6816 opts.module_regexp.empty () ? nullptr : opts.module_regexp.c_str (), args, 6817 opts.type_regexp.empty () ? nullptr : opts.type_regexp.c_str (), 6818 FUNCTIONS_DOMAIN); 6819} 6820 6821/* Implements the 'info module variables' command. */ 6822 6823static void 6824info_module_variables_command (const char *args, int from_tty) 6825{ 6826 info_modules_var_func_options opts; 6827 auto grp = make_info_modules_var_func_options_def_group (&opts); 6828 gdb::option::process_options 6829 (&args, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, grp); 6830 if (args != nullptr && *args == '\0') 6831 args = nullptr; 6832 6833 info_module_subcommand 6834 (opts.quiet, 6835 opts.module_regexp.empty () ? nullptr : opts.module_regexp.c_str (), args, 6836 opts.type_regexp.empty () ? nullptr : opts.type_regexp.c_str (), 6837 VARIABLES_DOMAIN); 6838} 6839 6840/* Command completer for 'info module ...' sub-commands. */ 6841 6842static void 6843info_module_var_func_command_completer (struct cmd_list_element *ignore, 6844 completion_tracker &tracker, 6845 const char *text, 6846 const char * /* word */) 6847{ 6848 6849 const auto group = make_info_modules_var_func_options_def_group (nullptr); 6850 if (gdb::option::complete_options 6851 (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, group)) 6852 return; 6853 6854 const char *word = advance_to_expression_complete_word_point (tracker, text); 6855 symbol_completer (ignore, tracker, text, word); 6856} 6857 6858 6859 6860void _initialize_symtab (); 6861void 6862_initialize_symtab () 6863{ 6864 cmd_list_element *c; 6865 6866 initialize_ordinary_address_classes (); 6867 6868 c = add_info ("variables", info_variables_command, 6869 info_print_args_help (_("\ 6870All global and static variable names or those matching REGEXPs.\n\ 6871Usage: info variables [-q] [-n] [-t TYPEREGEXP] [NAMEREGEXP]\n\ 6872Prints the global and static variables.\n"), 6873 _("global and static variables"), 6874 true)); 6875 set_cmd_completer_handle_brkchars (c, info_vars_funcs_command_completer); 6876 6877 c = add_info ("functions", info_functions_command, 6878 info_print_args_help (_("\ 6879All function names or those matching REGEXPs.\n\ 6880Usage: info functions [-q] [-n] [-t TYPEREGEXP] [NAMEREGEXP]\n\ 6881Prints the functions.\n"), 6882 _("functions"), 6883 true)); 6884 set_cmd_completer_handle_brkchars (c, info_vars_funcs_command_completer); 6885 6886 c = add_info ("types", info_types_command, _("\ 6887All type names, or those matching REGEXP.\n\ 6888Usage: info types [-q] [REGEXP]\n\ 6889Print information about all types matching REGEXP, or all types if no\n\ 6890REGEXP is given. The optional flag -q disables printing of headers.")); 6891 set_cmd_completer_handle_brkchars (c, info_types_command_completer); 6892 6893 const auto info_sources_opts 6894 = make_info_sources_options_def_group (nullptr); 6895 6896 static std::string info_sources_help 6897 = gdb::option::build_help (_("\ 6898All source files in the program or those matching REGEXP.\n\ 6899Usage: info sources [OPTION]... [REGEXP]\n\ 6900By default, REGEXP is used to match anywhere in the filename.\n\ 6901\n\ 6902Options:\n\ 6903%OPTIONS%"), 6904 info_sources_opts); 6905 6906 c = add_info ("sources", info_sources_command, info_sources_help.c_str ()); 6907 set_cmd_completer_handle_brkchars (c, info_sources_command_completer); 6908 6909 c = add_info ("modules", info_modules_command, 6910 _("All module names, or those matching REGEXP.")); 6911 set_cmd_completer_handle_brkchars (c, info_types_command_completer); 6912 6913 add_basic_prefix_cmd ("module", class_info, _("\ 6914Print information about modules."), 6915 &info_module_cmdlist, 0, &infolist); 6916 6917 c = add_cmd ("functions", class_info, info_module_functions_command, _("\ 6918Display functions arranged by modules.\n\ 6919Usage: info module functions [-q] [-m MODREGEXP] [-t TYPEREGEXP] [REGEXP]\n\ 6920Print a summary of all functions within each Fortran module, grouped by\n\ 6921module and file. For each function the line on which the function is\n\ 6922defined is given along with the type signature and name of the function.\n\ 6923\n\ 6924If REGEXP is provided then only functions whose name matches REGEXP are\n\ 6925listed. If MODREGEXP is provided then only functions in modules matching\n\ 6926MODREGEXP are listed. If TYPEREGEXP is given then only functions whose\n\ 6927type signature matches TYPEREGEXP are listed.\n\ 6928\n\ 6929The -q flag suppresses printing some header information."), 6930 &info_module_cmdlist); 6931 set_cmd_completer_handle_brkchars 6932 (c, info_module_var_func_command_completer); 6933 6934 c = add_cmd ("variables", class_info, info_module_variables_command, _("\ 6935Display variables arranged by modules.\n\ 6936Usage: info module variables [-q] [-m MODREGEXP] [-t TYPEREGEXP] [REGEXP]\n\ 6937Print a summary of all variables within each Fortran module, grouped by\n\ 6938module and file. For each variable the line on which the variable is\n\ 6939defined is given along with the type and name of the variable.\n\ 6940\n\ 6941If REGEXP is provided then only variables whose name matches REGEXP are\n\ 6942listed. If MODREGEXP is provided then only variables in modules matching\n\ 6943MODREGEXP are listed. If TYPEREGEXP is given then only variables whose\n\ 6944type matches TYPEREGEXP are listed.\n\ 6945\n\ 6946The -q flag suppresses printing some header information."), 6947 &info_module_cmdlist); 6948 set_cmd_completer_handle_brkchars 6949 (c, info_module_var_func_command_completer); 6950 6951 add_com ("rbreak", class_breakpoint, rbreak_command, 6952 _("Set a breakpoint for all functions matching REGEXP.")); 6953 6954 add_setshow_enum_cmd ("multiple-symbols", no_class, 6955 multiple_symbols_modes, &multiple_symbols_mode, 6956 _("\ 6957Set how the debugger handles ambiguities in expressions."), _("\ 6958Show how the debugger handles ambiguities in expressions."), _("\ 6959Valid values are \"ask\", \"all\", \"cancel\", and the default is \"all\"."), 6960 NULL, NULL, &setlist, &showlist); 6961 6962 add_setshow_boolean_cmd ("basenames-may-differ", class_obscure, 6963 &basenames_may_differ, _("\ 6964Set whether a source file may have multiple base names."), _("\ 6965Show whether a source file may have multiple base names."), _("\ 6966(A \"base name\" is the name of a file with the directory part removed.\n\ 6967Example: The base name of \"/home/user/hello.c\" is \"hello.c\".)\n\ 6968If set, GDB will canonicalize file names (e.g., expand symlinks)\n\ 6969before comparing them. Canonicalization is an expensive operation,\n\ 6970but it allows the same file be known by more than one base name.\n\ 6971If not set (the default), all source files are assumed to have just\n\ 6972one base name, and gdb will do file name comparisons more efficiently."), 6973 NULL, NULL, 6974 &setlist, &showlist); 6975 6976 add_setshow_zuinteger_cmd ("symtab-create", no_class, &symtab_create_debug, 6977 _("Set debugging of symbol table creation."), 6978 _("Show debugging of symbol table creation."), _("\ 6979When enabled (non-zero), debugging messages are printed when building\n\ 6980symbol tables. A value of 1 (one) normally provides enough information.\n\ 6981A value greater than 1 provides more verbose information."), 6982 NULL, 6983 NULL, 6984 &setdebuglist, &showdebuglist); 6985 6986 add_setshow_zuinteger_cmd ("symbol-lookup", no_class, &symbol_lookup_debug, 6987 _("\ 6988Set debugging of symbol lookup."), _("\ 6989Show debugging of symbol lookup."), _("\ 6990When enabled (non-zero), symbol lookups are logged."), 6991 NULL, NULL, 6992 &setdebuglist, &showdebuglist); 6993 6994 add_setshow_zuinteger_cmd ("symbol-cache-size", no_class, 6995 &new_symbol_cache_size, 6996 _("Set the size of the symbol cache."), 6997 _("Show the size of the symbol cache."), _("\ 6998The size of the symbol cache.\n\ 6999If zero then the symbol cache is disabled."), 7000 set_symbol_cache_size_handler, NULL, 7001 &maintenance_set_cmdlist, 7002 &maintenance_show_cmdlist); 7003 7004 add_setshow_boolean_cmd ("ignore-prologue-end-flag", no_class, 7005 &ignore_prologue_end_flag, 7006 _("Set if the PROLOGUE-END flag is ignored."), 7007 _("Show if the PROLOGUE-END flag is ignored."), 7008 _("\ 7009The PROLOGUE-END flag from the line-table entries is used to place \ 7010breakpoints past the prologue of functions. Disabeling its use use forces \ 7011the use of prologue scanners."), 7012 nullptr, nullptr, 7013 &maintenance_set_cmdlist, 7014 &maintenance_show_cmdlist); 7015 7016 7017 add_cmd ("symbol-cache", class_maintenance, maintenance_print_symbol_cache, 7018 _("Dump the symbol cache for each program space."), 7019 &maintenanceprintlist); 7020 7021 add_cmd ("symbol-cache-statistics", class_maintenance, 7022 maintenance_print_symbol_cache_statistics, 7023 _("Print symbol cache statistics for each program space."), 7024 &maintenanceprintlist); 7025 7026 cmd_list_element *maintenance_flush_symbol_cache_cmd 7027 = add_cmd ("symbol-cache", class_maintenance, 7028 maintenance_flush_symbol_cache, 7029 _("Flush the symbol cache for each program space."), 7030 &maintenanceflushlist); 7031 c = add_alias_cmd ("flush-symbol-cache", maintenance_flush_symbol_cache_cmd, 7032 class_maintenance, 0, &maintenancelist); 7033 deprecate_cmd (c, "maintenancelist flush symbol-cache"); 7034 7035 gdb::observers::executable_changed.attach (symtab_observer_executable_changed, 7036 "symtab"); 7037 gdb::observers::new_objfile.attach (symtab_new_objfile_observer, "symtab"); 7038 gdb::observers::free_objfile.attach (symtab_free_objfile_observer, "symtab"); 7039} 7040